Various Improvements

submodules/InviteLinksUI/Sources/InviteLinkEditController.swift

@@ -0,0 +1,428 @@
+import Foundation
+import UIKit
+import AsyncDisplayKit
+import Display
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import SyncCore
+import TelegramPresentationData
+import TelegramUIPreferences
+import ItemListUI
+import PresentationDataUtils
+import OverlayStatusController
+import AccountContext
+import AlertUI
+import PresentationDataUtils
+import AppBundle
+import ContextUI
+import TelegramStringFormatting
+
+private final class InviteLinkEditControllerArguments {
+    let context: AccountContext
+    let updateState: ((InviteLinkEditControllerState) -> InviteLinkEditControllerState) -> Void
+    let dismissInput: () -> Void
+    let revoke: () -> Void
+    
+    init(context: AccountContext, updateState: @escaping ((InviteLinkEditControllerState) -> InviteLinkEditControllerState) -> Void, dismissInput: @escaping () -> Void, revoke: @escaping () -> Void) {
+        self.context = context
+        self.updateState = updateState
+        self.dismissInput = dismissInput
+        self.revoke = revoke
+    }
+}
+
+private enum InviteLinksEditSection: Int32 {
+    case time
+    case usage
+    case revoke
+}
+
+private let invalidAmountCharacters = CharacterSet(charactersIn: "01234567890.,").inverted
+func isValidNumberOfUsers(_ number: String) -> Bool {
+    let number = normalizeArabicNumeralString(number, type: .western)
+    if number.rangeOfCharacter(from: invalidAmountCharacters) != nil || number == "0" {
+        return false
+    }
+    return true
+}
+
+private enum InviteLinksEditEntry: ItemListNodeEntry {
+    case timeHeader(PresentationTheme, String)
+    case timePicker(PresentationTheme, InviteLinkTimeLimit)
+    case timeExpiryDate(PresentationTheme, Int32?)
+    case timeCustomPicker(PresentationTheme, Int32?)
+    case timeInfo(PresentationTheme, String)
+    
+    case usageHeader(PresentationTheme, String)
+    case usagePicker(PresentationTheme, InviteLinkUsageLimit)
+    case usageCustomPicker(PresentationTheme, Int32?, Bool)
+    case usageInfo(PresentationTheme, String)
+    
+    case revoke(PresentationTheme, String)
+   
+    var section: ItemListSectionId {
+        switch self {
+            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 .timeHeader:
+                return 0
+            case .timePicker:
+                return 1
+            case .timeExpiryDate:
+                return 2
+            case .timeCustomPicker:
+                return 3
+            case .timeInfo:
+                return 4
+            case .usageHeader:
+                return 5
+            case .usagePicker:
+                return 6
+            case .usageCustomPicker:
+                return 7
+            case .usageInfo:
+                return 8
+            case .revoke:
+                return 9
+        }
+    }
+    
+    static func ==(lhs: InviteLinksEditEntry, rhs: InviteLinksEditEntry) -> Bool {
+        switch lhs {
+            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):
+                if case let .timePicker(rhsTheme, rhsValue) = rhs, lhsTheme === rhsTheme, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .timeExpiryDate(lhsTheme, lhsDate):
+                if case let .timeExpiryDate(rhsTheme, rhsDate) = rhs, lhsTheme === rhsTheme, lhsDate == rhsDate {
+                    return true
+                } else {
+                    return false
+                }
+            case let .timeCustomPicker(lhsTheme, lhsDate):
+                if case let .timeCustomPicker(rhsTheme, rhsDate) = rhs, lhsTheme === rhsTheme, lhsDate == rhsDate {
+                    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, lhsValue):
+                if case let .usagePicker(rhsTheme, rhsValue) = rhs, lhsTheme === rhsTheme, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .usageCustomPicker(lhsTheme, lhsValue, lhsFocused):
+                if case let .usageCustomPicker(rhsTheme, rhsValue, rhsFocused) = rhs, lhsTheme === rhsTheme, lhsValue == rhsValue, lhsFocused == rhsFocused {
+                    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 .timeHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .timePicker(_, value):
+                return ItemListInviteLinkTimeLimitItem(theme: presentationData.theme, strings: presentationData.strings, value: value, enabled: true, sectionId: self.section, updated: { value in
+                    arguments.updateState({ state in
+                        var updatedState = state
+                        if value != updatedState.time {
+                            updatedState.pickingTimeLimit = false
+                        }
+                        updatedState.time = value
+                        return updatedState
+                    })
+                })
+            case let .timeExpiryDate(_, value):
+                let text: String
+                if let value = value {
+                    text = stringForFullDate(timestamp: value, strings: presentationData.strings, dateTimeFormat: PresentationDateTimeFormat(timeFormat: .regular, dateFormat: .monthFirst, dateSeparator: ".", decimalSeparator: ".", groupingSeparator: "."))
+                } else {
+                    text = presentationData.strings.InviteLink_Create_TimeLimitExpiryDateNever
+                }
+                return ItemListDisclosureItem(presentationData: presentationData, title: presentationData.strings.InviteLink_Create_TimeLimitExpiryDate, label: text, sectionId: self.section, style: .blocks, disclosureStyle: .none, action: {
+                    arguments.dismissInput()
+                    arguments.updateState { state in
+                        var updatedState = state
+                        updatedState.pickingTimeLimit = !state.pickingTimeLimit
+                        return updatedState
+                    }
+                })
+            case let .timeCustomPicker(_, date):
+                return ItemListDatePickerItem(presentationData: presentationData, date: date, sectionId: self.section, style: .blocks, 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(_, value):
+                return ItemListInviteLinkUsageLimitItem(theme: presentationData.theme, strings: presentationData.strings, value: value, enabled: true, sectionId: self.section, updated: { value in
+                    arguments.dismissInput()
+                    arguments.updateState({ state in
+                        var updatedState = state
+                        if value != updatedState.usage {
+                            updatedState.pickingTimeLimit = false
+                        }
+                        updatedState.usage = value
+                        return updatedState
+                    })
+                })
+            case let .usageCustomPicker(theme, value, focused):
+                let text = value.flatMap { String($0) } ?? (focused ? "" : presentationData.strings.InviteLink_Create_UsersLimitNumberOfUsersUnlimited)
+                return ItemListSingleLineInputItem(presentationData: presentationData, title: NSAttributedString(string: presentationData.strings.InviteLink_Create_UsersLimitNumberOfUsers, textColor: theme.list.itemPrimaryTextColor), text: text, placeholder: "", type: .number, alignment: .right, tag: nil, sectionId: self.section, textUpdated: { updatedText in
+                    guard !updatedText.isEmpty else {
+                        return
+                    }
+                    arguments.updateState { state in
+                        var updatedState = state
+                        updatedState.usage = InviteLinkUsageLimit(value: Int32(updatedText))
+                        return updatedState
+                    }
+                }, shouldUpdateText: { text in
+                    return isValidNumberOfUsers(text)
+                }, updatedFocus: { focus in
+                    if focus {
+                        arguments.updateState { state in
+                            var updatedState = state
+                            updatedState.pickingTimeLimit = false
+                            updatedState.pickingUsageLimit = true
+                            return updatedState
+                        }
+                    } 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, title: text, kind: .destructive, alignment: .center, sectionId: self.section, style: .blocks, action: {
+                    arguments.revoke()
+                }, tag: nil)
+        }
+    }
+}
+
+private func inviteLinkEditControllerEntries(invite: ExportedInvitation?, state: InviteLinkEditControllerState, presentationData: PresentationData) -> [InviteLinksEditEntry] {
+    var entries: [InviteLinksEditEntry] = []
+    
+    entries.append(.timeHeader(presentationData.theme,  presentationData.strings.InviteLink_Create_TimeLimit.uppercased()))
+    
+    entries.append(.timePicker(presentationData.theme, state.time))
+    
+    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, time))
+    if state.pickingTimeLimit {
+        entries.append(.timeCustomPicker(presentationData.theme, time ?? currentTime))
+    }
+    entries.append(.timeInfo(presentationData.theme, presentationData.strings.InviteLink_Create_TimeLimitInfo))
+    
+    entries.append(.usageHeader(presentationData.theme,  presentationData.strings.InviteLink_Create_UsersLimit.uppercased()))
+    entries.append(.usagePicker(presentationData.theme, state.usage))
+    entries.append(.usageCustomPicker(presentationData.theme, state.usage.value, state.pickingUsageLimit))
+
+    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 usage: InviteLinkUsageLimit
+    var time: InviteLinkTimeLimit
+    var pickingTimeLimit = false
+    var pickingUsageLimit = false
+}
+
+public func inviteLinkEditController(context: AccountContext, peerId: PeerId, invite: ExportedInvitation?, completion: (() -> Void)? = nil) -> ViewController {
+    var presentControllerImpl: ((ViewController, ViewControllerPresentationArguments?) -> Void)?
+    let actionsDisposable = DisposableSet()
+
+    let initialState: InviteLinkEditControllerState
+    if let invite = invite {
+        var usageLimit = invite.usageLimit
+        if let limit = usageLimit, let count = invite.count, count > 0 {
+            usageLimit = limit - count
+        }
+        
+        let timeLimit: InviteLinkTimeLimit
+        let currentTime = Int32(CFAbsoluteTimeGetCurrent() + kCFAbsoluteTimeIntervalSince1970)
+        if let expireDate = invite.expireDate {
+            if currentTime >= expireDate {
+                timeLimit = .day
+            } else {
+                timeLimit = .custom(expireDate)
+            }
+        } else {
+            timeLimit = .unlimited
+        }
+        
+        initialState = InviteLinkEditControllerState(usage: InviteLinkUsageLimit(value: usageLimit), time: timeLimit, pickingTimeLimit: false, pickingUsageLimit: false)
+    } else {
+        initialState = InviteLinkEditControllerState(usage: .medium, time: .week, pickingTimeLimit: 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)?
+    
+    let arguments = InviteLinkEditControllerArguments(context: context, updateState: { f in
+        updateState(f)
+    }, dismissInput: {
+       dismissInputImpl?()
+    }, revoke: {
+        guard let invite = invite else {
+            return
+        }
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        let controller = ActionSheetController(presentationData: presentationData)
+        let dismissAction: () -> Void = { [weak controller] in
+            controller?.dismissAnimated()
+        }
+        controller.setItemGroups([
+            ActionSheetItemGroup(items: [
+                ActionSheetTextItem(title: presentationData.strings.GroupInfo_InviteLink_RevokeAlert_Text),
+                ActionSheetButtonItem(title: presentationData.strings.GroupInfo_InviteLink_RevokeLink, color: .destructive, action: {
+                    dismissAction()
+                    dismissImpl?()
+                    
+                    let _ = (revokePeerExportedInvitation(account: context.account, peerId: peerId, link: invite.link) |> deliverOnMainQueue).start(completed: {
+                        completion?()
+                    })
+                })
+            ]),
+            ActionSheetItemGroup(items: [ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, action: { dismissAction() })])
+        ])
+        presentControllerImpl?(controller, nil)
+    })
+    
+    let signal = combineLatest(context.sharedContext.presentationData, statePromise.get())
+    |> deliverOnMainQueue
+    |> map { presentationData, state -> (ItemListControllerState, (ItemListNodeState, Any)) in
+        let leftNavigationButton = ItemListNavigationButton(content: .text(presentationData.strings.Common_Cancel), style: .regular, enabled: true, action: {
+            dismissImpl?()
+        })
+        
+        let rightNavigationButton = ItemListNavigationButton(content: .text(presentationData.strings.Common_Done), style: .bold, enabled: true, action: {
+            let 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 = nil
+            }
+
+            let usageLimit = state.usage.value
+            if invite == nil {
+                let _ = (createPeerExportedInvitation(account: context.account, peerId: peerId, expireDate: expireDate, usageLimit: usageLimit)
+                |> deliverOnMainQueue).start(next: { result in
+                    completion?()
+                    dismissImpl?()
+                })
+            } else if let invite = invite {
+                let _ = (editPeerExportedInvitation(account: context.account, peerId: peerId, link: invite.link, expireDate: expireDate, usageLimit: usageLimit)
+                |> deliverOnMainQueue).start(next: { result in
+                    completion?()
+                    dismissImpl?()
+                })
+            }
+        })
+        
+        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, presentationData: presentationData), style: .blocks, emptyStateItem: nil, crossfadeState: false, animateChanges: false)
+        
+        return (controllerState, (listState, arguments))
+    }
+    |> afterDisposed {
+        actionsDisposable.dispose()
+    }
+    
+    let controller = ItemListController(context: context, state: signal)
+    presentControllerImpl = { [weak controller] c, p in
+        if let controller = controller {
+            controller.present(c, in: .window(.root), with: p)
+        }
+    }
+    dismissInputImpl = { [weak controller] in
+        controller?.view.endEditing(true)
+    }
+    dismissImpl = { [weak controller] in
+        controller?.dismiss()
+    }
+    return controller
+}

submodules/InviteLinksUI/Sources/InviteLinkHeaderItem.swift

@@ -0,0 +1,124 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+import AnimatedStickerNode
+import AppBundle
+
+class InviteLinkHeaderItem: ListViewItem, ItemListItem {
+    let theme: PresentationTheme
+    let text: String
+    let sectionId: ItemListSectionId
+    
+    init(theme: PresentationTheme, text: String, sectionId: ItemListSectionId) {
+        self.theme = theme
+        self.text = text
+        self.sectionId = sectionId
+    }
+    
+    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() })
+                })
+            }
+        }
+    }
+    
+    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.regular(13.0)
+
+class InviteLinkHeaderItemNode: ListViewItemNode {
+    private let titleNode: TextNode
+    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.animationNode = AnimatedStickerNode()
+        if let path = getAppBundle().path(forResource: "Invite", ofType: "tgs") {
+            self.animationNode.setup(source: AnimatedStickerNodeLocalFileSource(path: path), width: 192, height: 192, playbackMode: .loop, mode: .direct(cachePathPrefix: nil))
+            self.animationNode.visibility = true
+        }
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.titleNode)
+        self.addSubnode(self.animationNode)
+    }
+    
+    func asyncLayout() -> (_ item: InviteLinkHeaderItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        
+        return { item, params, neighbors in
+            let leftInset: CGFloat = 32.0 + params.leftInset
+            let topInset: CGFloat = 92.0
+            
+            let attributedText = NSAttributedString(string: item.text, font: titleFont, textColor: item.theme.list.freeTextColor)
+            let (titleLayout, titleApply) = makeTitleLayout(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)
+            let insets = itemListNeighborsGroupedInsets(neighbors)
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    strongSelf.accessibilityLabel = attributedText.string
+                                        
+                    let iconSize = CGSize(width: 96.0, height: 96.0)
+                    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)
+                    
+                    let _ = titleApply()
+                    strongSelf.titleNode.frame = CGRect(origin: CGPoint(x: floor((layout.size.width - titleLayout.size.width) / 2.0), y: topInset + 8.0), size: titleLayout.size)
+                }
+            })
+        }
+    }
+    
+    override func animateInsertion(_ currentTimestamp: Double, duration: Double, short: Bool) {
+        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/InviteLinkInviteController.swift

@@ -0,0 +1,667 @@
+import Foundation
+import UIKit
+import SwiftSignalKit
+import TelegramPresentationData
+import AppBundle
+import AsyncDisplayKit
+import Postbox
+import SyncCore
+import TelegramCore
+import Display
+import AccountContext
+import SolidRoundedButtonNode
+import ItemListUI
+import ItemListPeerItem
+import SectionHeaderItem
+import TelegramStringFormatting
+import MergeLists
+import ContextUI
+import ShareController
+import OverlayStatusController
+import PresentationDataUtils
+import DirectionalPanGesture
+
+class InviteLinkInviteInteraction {
+    let context: AccountContext
+    let mainLinkContextAction: (ExportedInvitation?, ASDisplayNode, ContextGesture?) -> Void
+    let copyLink: (ExportedInvitation) -> Void
+    let shareLink: (ExportedInvitation) -> Void
+    let manageLinks: () -> Void
+    
+    init(context: AccountContext, mainLinkContextAction: @escaping (ExportedInvitation?, ASDisplayNode, ContextGesture?) -> Void, copyLink: @escaping (ExportedInvitation) -> Void, shareLink: @escaping (ExportedInvitation) -> Void, manageLinks: @escaping () -> Void) {
+        self.context = context
+        self.mainLinkContextAction = mainLinkContextAction
+        self.copyLink = copyLink
+        self.shareLink = shareLink
+        self.manageLinks = manageLinks
+    }
+}
+
+private struct InviteLinkInviteTransaction {
+    let deletions: [ListViewDeleteItem]
+    let insertions: [ListViewInsertItem]
+    let updates: [ListViewUpdateItem]
+    let isLoading: Bool
+}
+
+private enum InviteLinkInviteEntryId: Hashable {
+    case mainLink
+    case links(Int32)
+}
+
+private enum InviteLinkInviteEntry: Comparable, Identifiable {
+    case mainLink(PresentationTheme, ExportedInvitation)
+    case links(Int32, PresentationTheme, [ExportedInvitation])
+    
+    var stableId: InviteLinkInviteEntryId {
+        switch self {
+            case .mainLink:
+                return .mainLink
+            case let .links(index, _, _):
+                return .links(index)
+        }
+    }
+    
+    static func ==(lhs: InviteLinkInviteEntry, rhs: InviteLinkInviteEntry) -> Bool {
+        switch lhs {
+            case let .mainLink(lhsTheme, lhsInvitation):
+                if case let .mainLink(rhsTheme, rhsInvitation) = rhs, lhsTheme === rhsTheme, lhsInvitation == rhsInvitation {
+                    return true
+                } else {
+                    return false
+                }
+            case let .links(lhsIndex, lhsTheme, lhsInvitations):
+                if case let .links(rhsIndex, rhsTheme, rhsInvitations) = rhs, lhsIndex == rhsIndex, lhsTheme === rhsTheme, lhsInvitations == rhsInvitations {
+                    return true
+                } else {
+                    return false
+                }
+        }
+    }
+    
+    static func <(lhs: InviteLinkInviteEntry, rhs: InviteLinkInviteEntry) -> Bool {
+        switch lhs {
+            case .mainLink:
+                switch rhs {
+                    case .mainLink:
+                        return false
+                    case .links:
+                        return true
+                }
+            case let .links(lhsIndex, _, _):
+                switch rhs {
+                    case .mainLink:
+                        return false
+                    case let .links(rhsIndex, _, _):
+                        return lhsIndex < rhsIndex
+                }
+        }
+    }
+    
+    func item(account: Account, presentationData: PresentationData, interaction: InviteLinkInviteInteraction) -> ListViewItem {
+        switch self {
+            case let .mainLink(_, invite):
+                return ItemListPermanentInviteLinkItem(context: interaction.context, presentationData: ItemListPresentationData(presentationData), invite: invite, peers: [], buttonColor: nil, sectionId: 0, style: .plain, shareAction: {
+                    interaction.shareLink(invite)
+                }, contextAction: { node in
+                    interaction.mainLinkContextAction(invite, node, nil)
+                }, viewAction: {
+                })
+            case let .links(_, _, invites):
+                return ItemListInviteLinkGridItem(presentationData: ItemListPresentationData(presentationData), invites: invites, sectionId: 0, style: .plain, tapAction: { invite in
+                    interaction.copyLink(invite)
+                }, contextAction: { invite, _ in
+                    interaction.shareLink(invite)
+                })
+        }
+    }
+}
+
+private func preparedTransition(from fromEntries: [InviteLinkInviteEntry], to toEntries: [InviteLinkInviteEntry], isLoading: Bool, account: Account, presentationData: PresentationData, interaction: InviteLinkInviteInteraction) -> InviteLinkInviteTransaction {
+    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(account: account, presentationData: presentationData, interaction: interaction), directionHint: nil) }
+    let updates = updateIndices.map { ListViewUpdateItem(index: $0.0, previousIndex: $0.2, item: $0.1.item(account: account, presentationData: presentationData, interaction: interaction), directionHint: nil) }
+    
+    return InviteLinkInviteTransaction(deletions: deletions, insertions: insertions, updates: updates, isLoading: isLoading)
+}
+
+public final class InviteLinkInviteController: ViewController {
+    private var controllerNode: Node {
+        return self.displayNode as! Node
+    }
+    
+    private var animatedIn = false
+    
+    private let context: AccountContext
+    private let peerId: PeerId
+    
+    private var presentationDataDisposable: Disposable?
+            
+    public init(context: AccountContext, peerId: PeerId) {
+        fatalError()
+        self.context = context
+        self.peerId = peerId
+                
+        super.init(navigationBarPresentationData: nil)
+        
+        self.navigationPresentation = .flatModal
+        self.statusBar.statusBarStyle = .Ignore
+        
+        self.blocksBackgroundWhenInOverlay = true
+        
+        self.presentationDataDisposable = (context.sharedContext.presentationData
+        |> deliverOnMainQueue).start(next: { [weak self] presentationData in
+            if let strongSelf = self {
+                strongSelf.controllerNode.updatePresentationData(presentationData)
+            }
+        })
+        
+        self.statusBar.statusBarStyle = .Ignore
+    }
+    
+    required init(coder aDecoder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    
+    deinit {
+        self.presentationDataDisposable?.dispose()
+    }
+    
+    override public func loadDisplayNode() {
+        self.displayNode = Node(context: self.context, peerId: self.peerId, controller: self)
+    }
+    
+    override public func loadView() {
+        super.loadView()
+    }
+    
+    private var didAppearOnce: Bool = false
+    private var isDismissed: Bool = false
+    public override func viewDidAppear(_ animated: Bool) {
+        super.viewDidAppear(animated)
+        
+        if !self.didAppearOnce {
+            self.didAppearOnce = true
+            
+            self.controllerNode.animateIn()
+        }
+    }
+    
+    override public func dismiss(completion: (() -> Void)? = nil) {
+        if !self.isDismissed {
+            self.isDismissed = true
+            self.didAppearOnce = false
+            
+            self.controllerNode.animateOut(completion: { [weak self] in
+                completion?()
+                self?.dismiss(animated: false)
+            })
+        }
+    }
+    
+    override public func containerLayoutUpdated(_ layout: ContainerViewLayout, transition: ContainedViewLayoutTransition) {
+        super.containerLayoutUpdated(layout, transition: transition)
+        
+        self.controllerNode.containerLayoutUpdated(layout, transition: transition)
+    }
+
+    class Node: ViewControllerTracingNode, UIGestureRecognizerDelegate {
+        private weak var controller: InviteLinkInviteController?
+        
+        private let context: AccountContext
+        private let peerId: PeerId
+        
+        private var interaction: InviteLinkInviteInteraction?
+        
+        private var presentationData: PresentationData
+        private let presentationDataPromise: Promise<PresentationData>
+                
+        private var disposable: Disposable?
+        
+        private let dimNode: ASDisplayNode
+        private let contentNode: ASDisplayNode
+        private let headerNode: ASDisplayNode
+        private let headerBackgroundNode: ASDisplayNode
+        private let titleNode: ImmediateTextNode
+        private let doneButton: HighlightableButtonNode
+        private let historyBackgroundNode: ASDisplayNode
+        private let historyBackgroundContentNode: ASDisplayNode
+        private var floatingHeaderOffset: CGFloat?
+        private let listNode: ListView
+        
+        private var enqueuedTransitions: [InviteLinkInviteTransaction] = []
+        
+        private var validLayout: ContainerViewLayout?
+        
+        private var presentationDataDisposable: Disposable?
+        private var revokeDisposable = MetaDisposable()
+        
+        init(context: AccountContext, peerId: PeerId, controller: InviteLinkInviteController) {
+            self.context = context
+            self.peerId = peerId
+            self.presentationData = context.sharedContext.currentPresentationData.with { $0 }
+            self.presentationDataPromise = Promise(self.presentationData)
+            self.controller = controller
+                        
+            self.dimNode = ASDisplayNode()
+            self.dimNode.backgroundColor = UIColor(white: 0.0, alpha: 0.5)
+            
+            self.contentNode = ASDisplayNode()
+            
+            self.headerNode = ASDisplayNode()
+            self.headerNode.clipsToBounds = true
+            
+            self.headerBackgroundNode = ASDisplayNode()
+            self.headerBackgroundNode.backgroundColor = self.presentationData.theme.list.plainBackgroundColor
+            self.headerBackgroundNode.cornerRadius = 16.0
+            
+            self.titleNode = ImmediateTextNode()
+            self.titleNode.maximumNumberOfLines = 1
+            self.titleNode.textAlignment = .center
+            self.titleNode.attributedText = NSAttributedString(string: self.presentationData.strings.InviteLink_InviteLink, font: Font.bold(17.0), textColor: self.presentationData.theme.actionSheet.primaryTextColor)
+
+            self.doneButton = HighlightableButtonNode()
+            self.doneButton.setTitle(self.presentationData.strings.Common_Done, with: Font.bold(17.0), with: self.presentationData.theme.actionSheet.controlAccentColor, for: .normal)
+            
+            self.historyBackgroundNode = ASDisplayNode()
+            self.historyBackgroundNode.isLayerBacked = true
+            
+            self.historyBackgroundContentNode = ASDisplayNode()
+            self.historyBackgroundContentNode.isLayerBacked = true
+            self.historyBackgroundContentNode.backgroundColor = self.presentationData.theme.list.plainBackgroundColor
+            
+            self.historyBackgroundNode.addSubnode(self.historyBackgroundContentNode)
+            
+            self.listNode = ListView()
+            self.listNode.verticalScrollIndicatorColor = UIColor(white: 0.0, alpha: 0.3)
+            self.listNode.verticalScrollIndicatorFollowsOverscroll = true
+            
+            super.init()
+            
+            self.backgroundColor = nil
+            self.isOpaque = false
+        
+            self.interaction = InviteLinkInviteInteraction(context: context, mainLinkContextAction: { [weak self] invite, node, gesture in
+                guard let node = node as? ContextExtractedContentContainingNode else {
+                    return
+                }
+                let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+                var items: [ContextMenuItem] = []
+
+                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)
+                    
+                    if let invite = invite {
+                        UIPasteboard.general.string = invite.link
+                        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+                        self?.controller?.present(OverlayStatusController(theme: presentationData.theme, type: .genericSuccess(presentationData.strings.Username_LinkCopied, false)), in: .window(.root))
+                    }
+                })))
+                
+                items.append(.action(ContextMenuActionItem(text: presentationData.strings.InviteLink_ContextGetQRCode, icon: { theme in
+                    return generateTintedImage(image: UIImage(bundleImageName: "Wallet/QrIcon"), color: theme.contextMenu.primaryColor)
+                }, action: { _, f in
+                    f(.dismissWithoutContent)
+                    
+                    if let invite = invite {
+                        let controller = InviteLinkQRCodeController(context: context, invite: invite)
+                        self?.controller?.present(controller, in: .window(.root))
+                    }
+                })))
+                
+                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.actionSheet.destructiveActionTextColor)
+                }, action: { _, f in
+                    f(.dismissWithoutContent)
+                
+                    let controller = ActionSheetController(presentationData: presentationData)
+                    let dismissAction: () -> Void = { [weak controller] in
+                        controller?.dismissAnimated()
+                    }
+                    controller.setItemGroups([
+                        ActionSheetItemGroup(items: [
+                            ActionSheetTextItem(title: presentationData.strings.GroupInfo_InviteLink_RevokeAlert_Text),
+                            ActionSheetButtonItem(title: presentationData.strings.GroupInfo_InviteLink_RevokeLink, color: .destructive, action: {
+                                dismissAction()
+                                
+                                self?.revokeDisposable.set((ensuredExistingPeerExportedInvitation(account: context.account, peerId: peerId, revokeExisted: true) |> deliverOnMainQueue).start(completed: {
+
+                                }))
+                            })
+                        ]),
+                        ActionSheetItemGroup(items: [ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, action: { dismissAction() })])
+                    ])
+                    self?.controller?.present(controller, in: .window(.root))
+                })))
+
+                let contextController = ContextController(account: context.account, presentationData: presentationData, source: .extracted(InviteLinkContextExtractedContentSource(controller: controller, sourceNode: node)), items: .single(items), reactionItems: [], gesture: gesture)
+                self?.controller?.presentInGlobalOverlay(contextController)
+            }, copyLink: { [weak self] invite in
+                let shareController = ShareController(context: context, subject: .url(invite.link))
+                self?.controller?.present(shareController, in: .window(.root))
+            }, shareLink: { [weak self] invite in
+                let shareController = ShareController(context: context, subject: .url(invite.link))
+                self?.controller?.present(shareController, in: .window(.root))
+            }, manageLinks: { [weak self] in
+                let controller = inviteLinkListController(context: context, peerId: peerId)
+                self?.controller?.push(controller)
+                self?.controller?.dismiss()
+            })
+            
+            let previousEntries = Atomic<[InviteLinkInviteEntry]?>(value: nil)
+            
+            let peerView = context.account.postbox.peerView(id: peerId)
+            self.disposable = (combineLatest(self.presentationDataPromise.get(), peerView)
+            |> deliverOnMainQueue).start(next: { [weak self] presentationData, view in
+                if let strongSelf = self {
+                    var entries: [InviteLinkInviteEntry] = []
+                    
+                    if let cachedData = view.cachedData as? CachedGroupData, let invite = cachedData.exportedInvitation {
+                        entries.append(.mainLink(presentationData.theme, invite))
+                    } else if let cachedData = view.cachedData as? CachedChannelData, let invite = cachedData.exportedInvitation {
+                        entries.append(.mainLink(presentationData.theme, invite))
+                    }
+                    
+                       
+                    let previousEntries = previousEntries.swap(entries)
+                    
+                    let transition = preparedTransition(from: previousEntries ?? [], to: entries, isLoading: false, account: context.account, presentationData: presentationData, interaction: strongSelf.interaction!)
+                    strongSelf.enqueueTransition(transition)
+                }
+            })
+            
+            self.listNode.preloadPages = true
+            self.listNode.stackFromBottom = true
+            self.listNode.updateFloatingHeaderOffset = { [weak self] offset, transition in
+                if let strongSelf = self {
+                    strongSelf.updateFloatingHeaderOffset(offset: offset, transition: transition)
+                }
+            }
+            self.listNode.visibleBottomContentOffsetChanged = { [weak self] offset in
+                if case let .known(value) = offset, value < 40.0 {
+                    
+                }
+            }
+            
+            self.addSubnode(self.dimNode)
+            self.addSubnode(self.contentNode)
+            self.contentNode.addSubnode(self.historyBackgroundNode)
+            self.contentNode.addSubnode(self.listNode)
+            self.contentNode.addSubnode(self.headerNode)
+            
+            self.headerNode.addSubnode(self.headerBackgroundNode)
+//            self.headerNode.addSubnode(self.titleNode)
+            self.headerNode.addSubnode(self.doneButton)
+            
+            self.doneButton.addTarget(self, action: #selector(self.doneButtonPressed), forControlEvents: .touchUpInside)
+            
+            self.presentationDataDisposable = context.sharedContext.presentationData.start(next: { [weak self] presentationData in
+                if let strongSelf = self {
+                    if strongSelf.presentationData.theme !== presentationData.theme || strongSelf.presentationData.strings !== presentationData.strings {
+                        strongSelf.updatePresentationData(presentationData)
+                    }
+                }
+            })
+        }
+        
+        deinit {
+            self.disposable?.dispose()
+            self.presentationDataDisposable?.dispose()
+            self.revokeDisposable.dispose()
+        }
+        
+        override func didLoad() {
+            super.didLoad()
+            
+            self.view.disablesInteractiveTransitionGestureRecognizer = true
+            self.view.disablesInteractiveModalDismiss = true
+            
+            self.dimNode.view.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(self.dimTapGesture(_:))))
+            
+            let panRecognizer = DirectionalPanGestureRecognizer(target: self, action: #selector(self.panGesture(_:)))
+            panRecognizer.delegate = self
+            panRecognizer.delaysTouchesBegan = false
+            panRecognizer.cancelsTouchesInView = true
+            self.view.addGestureRecognizer(panRecognizer)
+        }
+        
+        @objc private func doneButtonPressed() {
+            self.controller?.dismiss()
+        }
+        
+        func updatePresentationData(_ presentationData: PresentationData) {
+            self.presentationData = presentationData
+            self.presentationDataPromise.set(.single(presentationData))
+            
+            self.historyBackgroundContentNode.backgroundColor = self.presentationData.theme.list.plainBackgroundColor
+            self.headerBackgroundNode.backgroundColor = self.presentationData.theme.list.plainBackgroundColor
+            self.titleNode.attributedText = NSAttributedString(string: self.presentationData.strings.InviteLink_InviteLink, font: Font.bold(17.0), textColor: self.presentationData.theme.actionSheet.primaryTextColor)
+            self.doneButton.setTitle(self.presentationData.strings.Common_Done, with: Font.bold(17.0), with: self.presentationData.theme.actionSheet.controlAccentColor, for: .normal)
+        }
+        
+        private func enqueueTransition(_ transition: InviteLinkInviteTransaction) {
+            self.enqueuedTransitions.append(transition)
+            
+            if let _ = self.validLayout {
+                while !self.enqueuedTransitions.isEmpty {
+                    self.dequeueTransition()
+                }
+            }
+        }
+        
+        private func dequeueTransition() {
+            guard let _ = self.validLayout, let transition = self.enqueuedTransitions.first else {
+                return
+            }
+            self.enqueuedTransitions.remove(at: 0)
+            
+            self.listNode.transaction(deleteIndices: transition.deletions, insertIndicesAndItems: transition.insertions, updateIndicesAndItems: transition.updates, options: ListViewDeleteAndInsertOptions(), updateSizeAndInsets: nil, updateOpaqueState: nil, completion: { _ in
+            })
+        }
+        
+        func animateIn() {
+            guard let layout = self.validLayout else {
+                return
+            }
+            let transition = ContainedViewLayoutTransition.animated(duration: 0.4, curve: .spring)
+            
+            let initialBounds = self.contentNode.bounds
+            self.contentNode.bounds = initialBounds.offsetBy(dx: 0.0, dy: -layout.size.height)
+            transition.animateView({
+                self.contentNode.view.bounds = initialBounds
+            })
+            self.dimNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.3)
+        }
+        
+        func animateOut(completion: (() -> Void)?) {
+            guard let layout = self.validLayout else {
+                return
+            }
+            var offsetCompleted = false
+            let internalCompletion: () -> Void = {
+                if offsetCompleted {
+                    completion?()
+                }
+            }
+            
+            self.contentNode.layer.animateBoundsOriginYAdditive(from: self.contentNode.bounds.origin.y, to: -layout.size.height, duration: 0.3, timingFunction: kCAMediaTimingFunctionSpring, removeOnCompletion: false, completion: { _ in
+                offsetCompleted = true
+                internalCompletion()
+            })
+            self.dimNode.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.2, removeOnCompletion: false)
+        }
+        
+        func containerLayoutUpdated(_ layout: ContainerViewLayout, transition: ContainedViewLayoutTransition) {
+            self.validLayout = layout
+            
+            transition.updateFrame(node: self.dimNode, frame: CGRect(origin: CGPoint(), size: layout.size))
+            transition.updateFrame(node: self.contentNode, frame: CGRect(origin: CGPoint(), size: layout.size))
+            
+            var insets = UIEdgeInsets()
+            insets.left = layout.safeInsets.left
+            insets.right = layout.safeInsets.right
+            insets.bottom = layout.intrinsicInsets.bottom
+                    
+            let headerHeight: CGFloat = 54.0
+            let visibleItemsHeight: CGFloat = 147.0 + floor(52.0 * 3.5)
+        
+            let layoutTopInset: CGFloat = max(layout.statusBarHeight ?? 0.0, layout.safeInsets.top)
+            
+            let listTopInset = layoutTopInset + headerHeight
+            let listNodeSize = CGSize(width: layout.size.width, height: layout.size.height - listTopInset)
+            
+            insets.top = max(0.0, listNodeSize.height - visibleItemsHeight)
+                        
+            let (duration, curve) = listViewAnimationDurationAndCurve(transition: transition)
+            let updateSizeAndInsets = ListViewUpdateSizeAndInsets(size: listNodeSize, insets: insets, duration: duration, curve: curve)
+            self.listNode.transaction(deleteIndices: [], insertIndicesAndItems: [], updateIndicesAndItems: [], options: [.Synchronous, .LowLatency], scrollToItem: nil, updateSizeAndInsets: updateSizeAndInsets, stationaryItemRange: nil, updateOpaqueState: nil, completion: { _ in })
+            
+            transition.updateFrame(node: self.listNode, frame: CGRect(origin: CGPoint(x: 0.0, y: listTopInset), size: listNodeSize))
+            
+            transition.updateFrame(node: self.headerBackgroundNode, frame: CGRect(x: 0.0, y: 0.0, width: layout.size.width, height: 68.0))
+            
+            let titleSize = self.titleNode.updateLayout(CGSize(width: layout.size.width, height: headerHeight))
+            let titleFrame = CGRect(origin: CGPoint(x: floor((layout.size.width - titleSize.width) / 2.0), y: 18.0), size: titleSize)
+            transition.updateFrame(node: self.titleNode, frame: titleFrame)
+            
+            let doneSize = self.doneButton.measure(CGSize(width: layout.size.width, height: headerHeight))
+            let doneFrame = CGRect(origin: CGPoint(x: layout.size.width - doneSize.width - 16.0, y: 18.0), size: doneSize)
+            transition.updateFrame(node: self.doneButton, frame: doneFrame)
+        }
+        
+        override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+            let result = super.hitTest(point, with: event)
+
+            if result === self.headerNode.view {
+                return self.view
+            }
+            
+            if result === self.headerNode.view {
+                return self.view
+            }
+            
+            if !self.bounds.contains(point) {
+                return nil
+            }
+            if point.y < self.headerNode.frame.minY {
+                return self.dimNode.view
+            }
+            return result
+        }
+        
+        @objc func dimTapGesture(_ recognizer: UITapGestureRecognizer) {
+            if case .ended = recognizer.state {
+                self.controller?.dismiss()
+            }
+        }
+        
+        private var panGestureArguments: CGFloat?
+        
+        @objc func panGesture(_ recognizer: UIPanGestureRecognizer) {
+            let contentOffset = self.listNode.visibleContentOffset()
+            switch recognizer.state {
+                case .began:
+                    self.panGestureArguments = 0.0
+                case .changed:
+                    var translation = recognizer.translation(in: self.contentNode.view).y
+                    if let currentPanOffset = self.panGestureArguments {
+                        
+
+                        if case let .known(value) = contentOffset, value <= 0.5 {
+                        } else {
+                            translation = currentPanOffset
+                        }
+
+                        self.panGestureArguments = translation
+                    }
+                    
+                    var bounds = self.contentNode.bounds
+                    bounds.origin.y = -translation
+                    bounds.origin.y = min(0.0, bounds.origin.y)
+                    self.contentNode.bounds = bounds
+                case .ended:
+                    let translation = recognizer.translation(in: self.contentNode.view)
+                    var velocity = recognizer.velocity(in: self.contentNode.view)
+
+                    if case let .known(value) = contentOffset, value > 0.0 {
+                        velocity = CGPoint()
+                    } else if case .unknown = contentOffset {
+                        velocity = CGPoint()
+                    }
+
+                    var bounds = self.contentNode.bounds
+                    bounds.origin.y = -translation.y
+                    bounds.origin.y = min(0.0, bounds.origin.y)
+
+                    self.panGestureArguments = nil
+                    if bounds.minY < -60 || (bounds.minY < 0.0 && velocity.y > 300.0) {
+                        self.controller?.dismiss()
+                    } else {
+                        var bounds = self.contentNode.bounds
+                        let previousBounds = bounds
+                        bounds.origin.y = 0.0
+                        self.contentNode.bounds = bounds
+                        self.contentNode.layer.animateBounds(from: previousBounds, to: self.contentNode.bounds, duration: 0.3, timingFunction: CAMediaTimingFunctionName.easeInEaseOut.rawValue)
+                    }
+                case .cancelled:
+                    self.panGestureArguments = nil
+
+                    let previousBounds = self.contentNode.bounds
+                    var bounds = self.contentNode.bounds
+                    bounds.origin.y = 0.0
+                    self.contentNode.bounds = bounds
+                    self.contentNode.layer.animateBounds(from: previousBounds, to: self.contentNode.bounds, duration: 0.3, timingFunction: CAMediaTimingFunctionName.easeInEaseOut.rawValue)
+                default:
+                    break
+            }
+        }
+        
+        private func updateFloatingHeaderOffset(offset: CGFloat, transition: ContainedViewLayoutTransition) {
+            guard let validLayout = self.validLayout else {
+                return
+            }
+            
+            self.floatingHeaderOffset = offset
+            
+            let layoutTopInset: CGFloat = max(validLayout.statusBarHeight ?? 0.0, validLayout.safeInsets.top)
+            
+            let controlsHeight: CGFloat = 44.0
+            
+            let listTopInset = layoutTopInset + controlsHeight
+            
+            let rawControlsOffset = offset + listTopInset - controlsHeight
+            let controlsOffset = max(layoutTopInset, rawControlsOffset)
+            let isOverscrolling = rawControlsOffset <= layoutTopInset
+            let controlsFrame = CGRect(origin: CGPoint(x: 0.0, y: controlsOffset), size: CGSize(width: validLayout.size.width, height: controlsHeight))
+            
+            let previousFrame = self.headerNode.frame
+            
+            if !controlsFrame.equalTo(previousFrame) {
+                self.headerNode.frame = controlsFrame
+                
+                let positionDelta = CGPoint(x: controlsFrame.minX - previousFrame.minX, y: controlsFrame.minY - previousFrame.minY)
+                
+                transition.animateOffsetAdditive(node: self.headerNode, offset: positionDelta.y)
+            }
+            
+//            transition.updateAlpha(node: self.headerNode.separatorNode, alpha: isOverscrolling ? 1.0 : 0.0)
+            
+            let backgroundFrame = CGRect(origin: CGPoint(x: 0.0, y: controlsFrame.maxY), size: CGSize(width: validLayout.size.width, height: validLayout.size.height))
+            
+            let previousBackgroundFrame = self.historyBackgroundNode.frame
+            
+            if !backgroundFrame.equalTo(previousBackgroundFrame) {
+                self.historyBackgroundNode.frame = backgroundFrame
+                self.historyBackgroundContentNode.frame = CGRect(origin: CGPoint(), size: backgroundFrame.size)
+                
+                let positionDelta = CGPoint(x: backgroundFrame.minX - previousBackgroundFrame.minX, y: backgroundFrame.minY - previousBackgroundFrame.minY)
+                
+                transition.animateOffsetAdditive(node: self.historyBackgroundNode, offset: positionDelta.y)
+            }
+        }
+    }
+}

submodules/InviteLinksUI/Sources/InviteLinkInviteHeaderItem.swift

@@ -0,0 +1,124 @@
+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 text: String
+    
+    init(theme: PresentationTheme, text: String) {
+        self.theme = theme
+        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.regular(13.0)
+
+class InviteLinkInviteHeaderItemNode: ListViewItemNode {
+    private let titleNode: TextNode
+    private var animationNode: AnimatedStickerNode
+    
+    private var item: InviteLinkInviteHeaderItem?
+    
+    init() {
+        self.titleNode = TextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        self.titleNode.contentMode = .left
+        self.titleNode.contentsScale = UIScreen.main.scale
+        
+        self.animationNode = AnimatedStickerNode()
+        if let path = getAppBundle().path(forResource: "Invite", ofType: "tgs") {
+            self.animationNode.setup(source: AnimatedStickerNodeLocalFileSource(path: path), width: 192, height: 192, playbackMode: .loop, mode: .direct(cachePathPrefix: nil))
+            self.animationNode.visibility = true
+        }
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.titleNode)
+        self.addSubnode(self.animationNode)
+    }
+    
+    func asyncLayout() -> (_ item: InviteLinkInviteHeaderItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        
+        return { item, params, neighbors in
+            let leftInset: CGFloat = 32.0 + params.leftInset
+            let topInset: CGFloat = 92.0
+            
+            let attributedText = NSAttributedString(string: item.text, font: titleFont, textColor: item.theme.list.freeTextColor)
+            let (titleLayout, titleApply) = makeTitleLayout(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)
+            let insets = itemListNeighborsGroupedInsets(neighbors)
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    strongSelf.accessibilityLabel = attributedText.string
+                                        
+                    let iconSize = CGSize(width: 96.0, height: 96.0)
+                    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)
+                    
+                    let _ = titleApply()
+                    strongSelf.titleNode.frame = CGRect(origin: CGPoint(x: floor((layout.size.width - titleLayout.size.width) / 2.0), y: topInset + 8.0), size: titleLayout.size)
+                }
+            })
+        }
+    }
+    
+    override func animateInsertion(_ currentTimestamp: Double, duration: Double, short: Bool) {
+        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/InviteLinkListController.swift

@@ -0,0 +1,619 @@
+import Foundation
+import UIKit
+import AsyncDisplayKit
+import Display
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import SyncCore
+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 ShareController
+
+private final class InviteLinkListControllerArguments {
+    let context: AccountContext
+    let shareMainLink: (ExportedInvitation?) -> Void
+    let openMainLink: (ExportedInvitation?) -> Void
+    let mainLinkContextAction: (ExportedInvitation?, ASDisplayNode, ContextGesture?) -> Void
+    let createLink: () -> Void
+    let openLink: (ExportedInvitation) -> Void
+    let linkContextAction: (ExportedInvitation?, ASDisplayNode, ContextGesture?) -> Void
+    let deleteAllRevokedLinks: () -> Void
+    
+    init(context: AccountContext, shareMainLink: @escaping (ExportedInvitation?) -> Void, openMainLink: @escaping (ExportedInvitation?) -> Void, mainLinkContextAction: @escaping (ExportedInvitation?, ASDisplayNode, ContextGesture?) -> Void, createLink: @escaping () -> Void, openLink: @escaping (ExportedInvitation?) -> Void, linkContextAction: @escaping (ExportedInvitation?, ASDisplayNode, ContextGesture?) -> Void, deleteAllRevokedLinks: @escaping () -> Void) {
+        self.context = context
+        self.shareMainLink = shareMainLink
+        self.openMainLink = openMainLink
+        self.mainLinkContextAction = mainLinkContextAction
+        self.createLink = createLink
+        self.openLink = openLink
+        self.linkContextAction = linkContextAction
+        self.deleteAllRevokedLinks = deleteAllRevokedLinks
+    }
+}
+
+private enum InviteLinksListSection: Int32 {
+    case header
+    case mainLink
+    case links
+    case revokedLinks
+}
+
+private enum InviteLinksListEntry: ItemListNodeEntry {
+    case header(PresentationTheme, String)
+   
+    case mainLinkHeader(PresentationTheme, String)
+    case mainLink(PresentationTheme, ExportedInvitation?, [Peer])
+    
+    case linksHeader(PresentationTheme, String)
+    case linksCreate(PresentationTheme, String)
+    case links(Int32, PresentationTheme, [ExportedInvitation]?)
+    case linksInfo(PresentationTheme, String)
+    case revokedLinksHeader(PresentationTheme, String)
+    case revokedLinksDeleteAll(PresentationTheme, String)
+    case revokedLinks(Int32, PresentationTheme, [ExportedInvitation]?)
+    
+    var section: ItemListSectionId {
+        switch self {
+            case .header:
+                return InviteLinksListSection.header.rawValue
+            case .mainLinkHeader, .mainLink:
+                return InviteLinksListSection.mainLink.rawValue
+            case .linksHeader, .linksCreate, .links, .linksInfo:
+                return InviteLinksListSection.links.rawValue
+            case .revokedLinksHeader, .revokedLinksDeleteAll, .revokedLinks:
+                return InviteLinksListSection.revokedLinks.rawValue
+        }
+    }
+    
+    var stableId: Int32 {
+        switch self {
+            case .header:
+                return 0
+            case .mainLinkHeader:
+                return 1
+            case .mainLink:
+                return 2
+            case .linksHeader:
+                return 3
+            case .linksCreate:
+                return 4
+            case let .links(index, _, _):
+                return 5 + index
+            case .linksInfo:
+                return 10000
+            case .revokedLinksHeader:
+                return 10001
+            case .revokedLinksDeleteAll:
+                return 10002
+            case let .revokedLinks(index, _, _):
+                return 10003 + index
+        }
+    }
+    
+    static func ==(lhs: InviteLinksListEntry, rhs: InviteLinksListEntry) -> 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 .mainLinkHeader(lhsTheme, lhsText):
+                if case let .mainLinkHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .mainLink(lhsTheme, lhsInvite, lhsPeers):
+                if case let .mainLink(rhsTheme, rhsInvite, rhsPeers) = rhs, lhsTheme === rhsTheme, lhsInvite == rhsInvite, arePeerArraysEqual(lhsPeers, rhsPeers) {
+                    return true
+                } else {
+                    return false
+                }
+            case let .linksHeader(lhsTheme, lhsText):
+                if case let .linksHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .linksCreate(lhsTheme, lhsText):
+                if case let .linksCreate(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .links(lhsIndex, lhsTheme, lhsLinks):
+                if case let .links(rhsIndex, rhsTheme, rhsLinks) = rhs, lhsIndex == rhsIndex, lhsTheme === rhsTheme, lhsLinks == rhsLinks {
+                    return true
+                } else {
+                    return false
+                }
+            case let .linksInfo(lhsTheme, lhsText):
+                if case let .linksInfo(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .revokedLinksHeader(lhsTheme, lhsText):
+                if case let .revokedLinksHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .revokedLinksDeleteAll(lhsTheme, lhsText):
+                if case let .revokedLinksDeleteAll(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .revokedLinks(lhsIndex, lhsTheme, lhsLinks):
+                if case let .revokedLinks(rhsIndex, rhsTheme, rhsLinks) = rhs, lhsIndex == rhsIndex, lhsTheme === rhsTheme, lhsLinks == rhsLinks {
+                    return true
+                } else {
+                    return false
+                }
+        }
+    }
+    
+    static func <(lhs: InviteLinksListEntry, rhs: InviteLinksListEntry) -> Bool {
+        return lhs.stableId < rhs.stableId
+    }
+    
+    func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
+        let arguments = arguments as! InviteLinkListControllerArguments
+        switch self {
+            case let .header(theme, text):
+                return InviteLinkHeaderItem(theme: theme, text: text, sectionId: self.section)
+            case let .mainLinkHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .mainLink(_, invite, peers):
+                return ItemListPermanentInviteLinkItem(context: arguments.context, presentationData: presentationData, invite: invite, peers: peers, buttonColor: nil, sectionId: self.section, style: .blocks, shareAction: {
+                    arguments.shareMainLink(invite)
+                }, contextAction: { node in
+                    arguments.mainLinkContextAction(invite, node, nil)
+                }, viewAction: {
+                    if let invite = invite {
+                        arguments.openLink(invite)
+                    }
+                })
+            case let .linksHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .linksCreate(theme, text):
+                return ItemListPeerActionItem(presentationData: presentationData, icon: PresentationResourcesItemList.plusIconImage(theme), title: text, hasSeparator: false, sectionId: self.section, editing: false, action: {
+                    arguments.createLink()
+                })
+            case let .links(_, _, invites):
+                return ItemListInviteLinkGridItem(presentationData: presentationData, invites: invites, sectionId: self.section, style: .blocks, tapAction: { invite in
+                    arguments.openLink(invite)
+                }, contextAction: { invite, node in
+                    arguments.linkContextAction(invite, node, nil)
+                })
+            case let .linksInfo(_, text):
+                return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: self.section)
+            case let .revokedLinksHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .revokedLinksDeleteAll(theme, text):
+                return ItemListPeerActionItem(presentationData: presentationData, icon: PresentationResourcesItemList.deleteIconImage(theme), title: text, hasSeparator: false, sectionId: self.section, color: .destructive, editing: false, action: {
+                    arguments.deleteAllRevokedLinks()
+                })
+            case let .revokedLinks(_, _, invites):
+                return ItemListInviteLinkGridItem(presentationData: presentationData, invites: invites, sectionId: self.section, style: .blocks, tapAction: { invite in
+                    arguments.openLink(invite)
+                }, contextAction: { invite, node in
+                    arguments.linkContextAction(invite, node, nil)
+                })
+        }
+    }
+}
+
+private func inviteLinkListControllerEntries(presentationData: PresentationData, view: PeerView, invites: [ExportedInvitation]?, revokedInvites: [ExportedInvitation]?, mainPeers: [Peer]) -> [InviteLinksListEntry] {
+    var entries: [InviteLinksListEntry] = []
+    
+    entries.append(.header(presentationData.theme, presentationData.strings.InviteLink_CreatePrivateLinkHelp))
+    entries.append(.mainLinkHeader(presentationData.theme, presentationData.strings.InviteLink_PermanentLink.uppercased()))
+        
+    let mainInvite: ExportedInvitation?
+    if let invites = invites, let invite = invites.first(where: { $0.isPermanent && !$0.isRevoked }) {
+        mainInvite = invite
+    } else if let invite = (view.cachedData as? CachedChannelData)?.exportedInvitation {
+        mainInvite = invite
+    } else if let invite = (view.cachedData as? CachedGroupData)?.exportedInvitation {
+        mainInvite = invite
+    } else {
+        mainInvite = nil
+    }
+    entries.append(.mainLink(presentationData.theme, mainInvite, mainPeers))
+    
+    entries.append(.linksHeader(presentationData.theme, presentationData.strings.InviteLink_AdditionalLinks.uppercased()))
+    entries.append(.linksCreate(presentationData.theme, presentationData.strings.InviteLink_Create))
+    
+    var additionalInvites: [ExportedInvitation]?
+    if let invites = invites {
+        additionalInvites = invites.filter { $0.link != mainInvite?.link }
+    }
+    if let additionalInvites = additionalInvites {
+        var index: Int32 = 0
+        for i in stride(from: 0, to: additionalInvites.endIndex, by: 2) {
+            var invitesPair: [ExportedInvitation] = []
+            invitesPair.append(additionalInvites[i])
+            if i + 1 < additionalInvites.count {
+                invitesPair.append(additionalInvites[i + 1])
+            }
+            entries.append(.links(index, presentationData.theme, invitesPair))
+            index += 1
+        }
+    }
+    entries.append(.linksInfo(presentationData.theme, presentationData.strings.InviteLink_CreateInfo))
+    
+    if let revokedInvites = revokedInvites, !revokedInvites.isEmpty {
+        entries.append(.revokedLinksHeader(presentationData.theme, presentationData.strings.InviteLink_RevokedLinks.uppercased()))
+        entries.append(.revokedLinksDeleteAll(presentationData.theme, presentationData.strings.InviteLink_DeleteAllRevokedLinks))
+        
+        var index: Int32 = 0
+        for i in stride(from: 0, to: revokedInvites.endIndex, by: 2) {
+            var invitesPair: [ExportedInvitation] = []
+            invitesPair.append(revokedInvites[i])
+            if i + 1 < revokedInvites.count {
+                invitesPair.append(revokedInvites[i + 1])
+            }
+            entries.append(.revokedLinks(index, presentationData.theme, invitesPair))
+            index += 1
+        }
+    }
+   
+    return entries
+}
+
+private struct InviteLinkListControllerState: Equatable {
+    var revokingPrivateLink: Bool
+}
+
+
+public func inviteLinkListController(context: AccountContext, peerId: PeerId) -> ViewController {
+    var pushControllerImpl: ((ViewController) -> Void)?
+    var presentControllerImpl: ((ViewController, ViewControllerPresentationArguments?) -> Void)?
+    var presentInGlobalOverlayImpl: ((ViewController) -> Void)?
+    
+    let actionsDisposable = DisposableSet()
+    
+    let statePromise = ValuePromise(InviteLinkListControllerState(revokingPrivateLink: false), ignoreRepeated: true)
+    let stateValue = Atomic(value: InviteLinkListControllerState(revokingPrivateLink: false))
+    let updateState: ((InviteLinkListControllerState) -> InviteLinkListControllerState) -> Void = { f in
+        statePromise.set(stateValue.modify { f($0) })
+    }
+    
+    let revokeLinkDisposable = MetaDisposable()
+    actionsDisposable.add(revokeLinkDisposable)
+    
+    let deleteAllRevokedLinksDisposable = MetaDisposable()
+    actionsDisposable.add(deleteAllRevokedLinksDisposable)
+    
+    actionsDisposable.add((context.account.viewTracker.peerView(peerId) |> filter { $0.cachedData != nil } |> take(1) |> mapToSignal { view -> Signal<String?, NoError> in
+        return ensuredExistingPeerExportedInvitation(account: context.account, peerId: peerId)
+        |> mapToSignal { _ -> Signal<String?, NoError> in
+            return .complete()
+        }
+    }).start())
+    
+    var getControllerImpl: (() -> ViewController?)?
+    
+    let invitesPromise = Promise<ExportedInvitations?>()
+    invitesPromise.set(.single(nil)
+    |> then(peerExportedInvitations(account: context.account, peerId: peerId, revoked: false)))
+    
+    let revokedInvitesPromise = Promise<ExportedInvitations?>()
+    revokedInvitesPromise.set(.single(nil)
+    |> then(peerExportedInvitations(account: context.account, peerId: peerId, revoked: true)))
+    
+    let arguments = InviteLinkListControllerArguments(context: context, shareMainLink: { invite in
+        if let invite = invite {
+            let shareController = ShareController(context: context, subject: .url(invite.link))
+            presentControllerImpl?(shareController, nil)
+        }
+    }, openMainLink: { invite in
+        if let invite = invite {
+            let controller = InviteLinkViewController(context: context, peerId: peerId, invite: invite, importersContext: nil)
+            pushControllerImpl?(controller)
+        }
+    }, mainLinkContextAction: { invite, node, gesture in
+        guard let node = node as? ContextExtractedContentContainingNode, let controller = getControllerImpl?() else {
+            return
+        }
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        var items: [ContextMenuItem] = []
+
+        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)
+            
+            if let invite = invite {
+                UIPasteboard.general.string = invite.link
+                let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+                presentControllerImpl?(OverlayStatusController(theme: presentationData.theme, type: .genericSuccess(presentationData.strings.Username_LinkCopied, false)), nil)
+            }
+        })))
+        
+        items.append(.action(ContextMenuActionItem(text: presentationData.strings.InviteLink_ContextGetQRCode, icon: { theme in
+            return generateTintedImage(image: UIImage(bundleImageName: "Wallet/QrIcon"), color: theme.contextMenu.primaryColor)
+        }, action: { _, f in
+            f(.dismissWithoutContent)
+            
+            if let invite = invite {
+                let controller = InviteLinkQRCodeController(context: context, invite: invite)
+                presentControllerImpl?(controller, 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.actionSheet.destructiveActionTextColor)
+        }, action: { _, f in
+            f(.dismissWithoutContent)
+        
+            let controller = ActionSheetController(presentationData: presentationData)
+            let dismissAction: () -> Void = { [weak controller] in
+                controller?.dismissAnimated()
+            }
+            controller.setItemGroups([
+                ActionSheetItemGroup(items: [
+                    ActionSheetTextItem(title: presentationData.strings.GroupInfo_InviteLink_RevokeAlert_Text),
+                    ActionSheetButtonItem(title: presentationData.strings.GroupInfo_InviteLink_RevokeLink, color: .destructive, action: {
+                        dismissAction()
+                        
+                        var revoke = false
+                        updateState { state in
+                            if !state.revokingPrivateLink {
+                                revoke = true
+                                var updatedState = state
+                                updatedState.revokingPrivateLink = true
+                                return updatedState
+                            } else {
+                                return state
+                            }
+                        }
+                        if revoke {
+                            revokeLinkDisposable.set((ensuredExistingPeerExportedInvitation(account: context.account, peerId: peerId, revokeExisted: true) |> deliverOnMainQueue).start(completed: {
+                                updateState { state in
+                                    var updatedState = state
+                                    updatedState.revokingPrivateLink = false
+                                    return updatedState
+                                }
+                                invitesPromise.set(peerExportedInvitations(account: context.account, peerId: peerId, revoked: false))
+                            }))
+                        }
+                    })
+                ]),
+                ActionSheetItemGroup(items: [ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, action: { dismissAction() })])
+            ])
+            presentControllerImpl?(controller, ViewControllerPresentationArguments(presentationAnimation: .modalSheet))
+        })))
+
+        let contextController = ContextController(account: context.account, presentationData: presentationData, source: .extracted(InviteLinkContextExtractedContentSource(controller: controller, sourceNode: node)), items: .single(items), reactionItems: [], gesture: gesture)
+        presentInGlobalOverlayImpl?(contextController)
+    }, createLink: {
+        let controller = inviteLinkEditController(context: context, peerId: peerId, invite: nil, completion: {
+            invitesPromise.set(peerExportedInvitations(account: context.account, peerId: peerId, revoked: false))
+        })
+        controller.navigationPresentation = .modal
+        pushControllerImpl?(controller)
+    }, openLink: { invite in
+        if let invite = invite {
+            let controller = InviteLinkViewController(context: context, peerId: peerId, invite: invite, importersContext: nil)
+            pushControllerImpl?(controller)
+        }
+    }, linkContextAction: { invite, node, gesture in
+        guard let node = node as? ContextExtractedContentContainingNode, 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.InviteLink_ContextCopy, icon: { theme in
+            return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Copy"), color: theme.contextMenu.primaryColor)
+        }, action: { _, f in
+            f(.dismissWithoutContent)
+            
+            UIPasteboard.general.string = invite.link
+            let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+            presentControllerImpl?(OverlayStatusController(theme: presentationData.theme, type: .genericSuccess(presentationData.strings.Username_LinkCopied, false)), nil)
+        })))
+        
+        if !invite.isRevoked {
+            items.append(.action(ContextMenuActionItem(text: presentationData.strings.InviteLink_ContextGetQRCode, icon: { theme in
+                return generateTintedImage(image: UIImage(bundleImageName: "Wallet/QrIcon"), color: theme.contextMenu.primaryColor)
+            }, action: { _, f in
+                f(.dismissWithoutContent)
+                
+                let controller = InviteLinkQRCodeController(context: context, invite: invite)
+                presentControllerImpl?(controller, nil)
+            })))
+        
+            items.append(.action(ContextMenuActionItem(text: presentationData.strings.InviteLink_ContextEdit, icon: { theme in
+                return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Edit"), color: theme.contextMenu.primaryColor)
+            }, action: { _, f in
+                f(.dismissWithoutContent)
+            
+                let controller = inviteLinkEditController(context: context, peerId: peerId, invite: invite, completion: {
+                    invitesPromise.set(peerExportedInvitations(account: context.account, peerId: peerId, revoked: false))
+                })
+                controller.navigationPresentation = .modal
+                pushControllerImpl?(controller)
+            })))
+        }
+        
+        if invite.isRevoked {
+            items.append(.action(ContextMenuActionItem(text: presentationData.strings.InviteLink_ContextDelete, textColor: .destructive, icon: { theme in
+                return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Delete"), color: theme.actionSheet.destructiveActionTextColor)
+            }, action: { _, f in
+                f(.dismissWithoutContent)
+            
+                let controller = ActionSheetController(presentationData: presentationData)
+                let dismissAction: () -> Void = { [weak controller] in
+                    controller?.dismissAnimated()
+                }
+                controller.setItemGroups([
+                    ActionSheetItemGroup(items: [
+                        ActionSheetTextItem(title: presentationData.strings.GroupInfo_InviteLink_RevokeAlert_Text),
+                        ActionSheetButtonItem(title: presentationData.strings.GroupInfo_InviteLink_RevokeLink, color: .destructive, action: {
+                            dismissAction()
+                            
+                            revokeLinkDisposable.set((revokePeerExportedInvitation(account: context.account, peerId: peerId, link: invite.link) |> deliverOnMainQueue).start(completed: {
+
+                            }))
+                        })
+                    ]),
+                    ActionSheetItemGroup(items: [ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, action: { dismissAction() })])
+                ])
+                presentControllerImpl?(controller, ViewControllerPresentationArguments(presentationAnimation: .modalSheet))
+            })))
+        } else {
+            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.actionSheet.destructiveActionTextColor)
+            }, action: { _, f in
+                f(.dismissWithoutContent)
+            
+                let controller = ActionSheetController(presentationData: presentationData)
+                let dismissAction: () -> Void = { [weak controller] in
+                    controller?.dismissAnimated()
+                }
+                controller.setItemGroups([
+                    ActionSheetItemGroup(items: [
+                        ActionSheetTextItem(title: presentationData.strings.GroupInfo_InviteLink_RevokeAlert_Text),
+                        ActionSheetButtonItem(title: presentationData.strings.GroupInfo_InviteLink_RevokeLink, color: .destructive, action: {
+                            dismissAction()
+                            
+                            revokeLinkDisposable.set((revokePeerExportedInvitation(account: context.account, peerId: peerId, link: invite.link) |> deliverOnMainQueue).start(completed: {
+
+                            }))
+                        })
+                    ]),
+                    ActionSheetItemGroup(items: [ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, action: { dismissAction() })])
+                ])
+                presentControllerImpl?(controller, ViewControllerPresentationArguments(presentationAnimation: .modalSheet))
+            })))
+        }
+
+        let contextController = ContextController(account: context.account, presentationData: presentationData, source: .extracted(InviteLinkContextExtractedContentSource(controller: controller, sourceNode: node)), items: .single(items), reactionItems: [], gesture: gesture)
+        presentInGlobalOverlayImpl?(contextController)
+    }, deleteAllRevokedLinks: {
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        let controller = ActionSheetController(presentationData: presentationData)
+        let dismissAction: () -> Void = { [weak controller] in
+            controller?.dismissAnimated()
+        }
+        controller.setItemGroups([
+            ActionSheetItemGroup(items: [
+                ActionSheetTextItem(title: presentationData.strings.InviteLink_DeleteAllRevokedLinksAlert_Text),
+                ActionSheetButtonItem(title: presentationData.strings.InviteLink_DeleteAllRevokedLinksAlert_Action, color: .destructive, action: {
+                    dismissAction()
+                    
+                    deleteAllRevokedLinksDisposable.set((deleteAllRevokedPeerExportedInvitations(account: context.account, peerId: peerId) |> deliverOnMainQueue).start(completed: {
+
+                    }))
+                })
+            ]),
+            ActionSheetItemGroup(items: [ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, action: { dismissAction() })])
+        ])
+        presentControllerImpl?(controller, ViewControllerPresentationArguments(presentationAnimation: .modalSheet))
+    })
+        
+    let peerView = context.account.viewTracker.peerView(peerId)
+    |> deliverOnMainQueue
+    
+    let importersState = Promise<PeerInvitationImportersState?>(nil)
+    let importersContext: Signal<PeerInvitationImportersContext, NoError> = peerView
+    |> mapToSignal { view -> Signal<ExportedInvitation, NoError> in
+        if let cachedData = view.cachedData as? CachedGroupData, let exportedInvitation = cachedData.exportedInvitation {
+            return .single(exportedInvitation)
+        } else if let cachedData = view.cachedData as? CachedChannelData, let exportedInvitation = cachedData.exportedInvitation {
+            return .single(exportedInvitation)
+        } else {
+            return .complete()
+        }
+    }
+    |> distinctUntilChanged
+    |> deliverOnMainQueue
+    |> map { invite -> PeerInvitationImportersContext in
+        return PeerInvitationImportersContext(account: context.account, peerId: peerId, invite: invite)
+    } |> afterNext { context in
+        importersState.set(context.state |> map(Optional.init))
+    }
+    
+    let signal = combineLatest(context.sharedContext.presentationData, peerView, importersContext, importersState.get(), invitesPromise.get(), revokedInvitesPromise.get())
+    |> deliverOnMainQueue
+    |> map { presentationData, view, importersContext, importers, invites, revokedInvites -> (ItemListControllerState, (ItemListNodeState, Any)) in
+        let controllerState = ItemListControllerState(presentationData: ItemListPresentationData(presentationData), title: .text(presentationData.strings.InviteLink_Title), leftNavigationButton: nil, rightNavigationButton: nil, backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back), animateChanges: true)
+        let listState = ItemListNodeState(presentationData: ItemListPresentationData(presentationData), entries: inviteLinkListControllerEntries(presentationData: presentationData, view: view, invites: invites?.list, revokedInvites: revokedInvites?.list, mainPeers: importers?.importers.compactMap { $0.peer.peer } ?? []), style: .blocks, emptyStateItem: nil, crossfadeState: false, animateChanges: false)
+        
+        return (controllerState, (listState, arguments))
+    }
+    |> afterDisposed {
+        actionsDisposable.dispose()
+    }
+    
+    let controller = ItemListController(context: context, state: signal)
+    controller.didDisappear = { [weak controller] _ in
+        controller?.clearItemNodesHighlight(animated: true)
+    }
+    controller.visibleBottomContentOffsetChanged = { offset in
+        if case let .known(value) = offset, value < 40.0 {
+            
+        }
+    }
+    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)
+        }
+    }
+    getControllerImpl = { [weak controller] in
+        return controller
+    }
+    return controller
+}
+
+
+final class InviteLinkContextExtractedContentSource: ContextExtractedContentSource {
+    var keepInPlace: Bool
+    let ignoreContentTouches: Bool = true
+    let blurBackground: Bool
+    
+    private let controller: ViewController
+    private let sourceNode: ContextExtractedContentContainingNode
+    
+    init(controller: ViewController, sourceNode: ContextExtractedContentContainingNode) {
+        self.controller = controller
+        self.sourceNode = sourceNode
+        self.keepInPlace = true
+        self.blurBackground = false
+    }
+    
+    func takeView() -> ContextControllerTakeViewInfo? {
+        return ContextControllerTakeViewInfo(contentContainingNode: self.sourceNode, contentAreaInScreenSpace: UIScreen.main.bounds)
+    }
+    
+    func putBack() -> ContextControllerPutBackViewInfo? {
+        return ContextControllerPutBackViewInfo(contentAreaInScreenSpace: UIScreen.main.bounds)
+    }
+}

submodules/InviteLinksUI/Sources/InviteLinkQRCodeController.swift

@@ -0,0 +1,414 @@
+import Foundation
+import UIKit
+import SwiftSignalKit
+import TelegramPresentationData
+import AppBundle
+import AsyncDisplayKit
+import SyncCore
+import Display
+import QrCode
+import AccountContext
+import SolidRoundedButtonNode
+import AnimatedStickerNode
+
+private func shareQrCode(context: AccountContext, link: String) {
+    let _ = (qrCode(string: link, color: .black, backgroundColor: .white, icon: .custom(UIImage(bundleImageName: "Chat/Links/QrLogo")))
+    |> map { _, generator -> UIImage? in
+        let imageSize = CGSize(width: 768.0, height: 768.0)
+        let context = generator(TransformImageArguments(corners: ImageCorners(), imageSize: imageSize, boundingSize: imageSize, intrinsicInsets: UIEdgeInsets(), scale: 1.0))
+        return context?.generateImage()
+    }
+    |> deliverOnMainQueue).start(next: { image in
+        guard let image = image else {
+            return
+        }
+        
+        let activityController = UIActivityViewController(activityItems: [image], applicationActivities: nil)
+        context.sharedContext.applicationBindings.presentNativeController(activityController)
+    })
+}
+
+public final class InviteLinkQRCodeController: ViewController {
+    private var controllerNode: Node {
+        return self.displayNode as! Node
+    }
+    
+    private var animatedIn = false
+    
+    private let context: AccountContext
+    private let invite: ExportedInvitation
+
+    private var presentationDataDisposable: Disposable?
+    
+    private let idleTimerExtensionDisposable = MetaDisposable()
+    
+    public init(context: AccountContext, invite: ExportedInvitation) {
+        self.context = context
+        self.invite = invite
+        
+        super.init(navigationBarPresentationData: nil)
+        
+        self.statusBar.statusBarStyle = .Ignore
+        
+        self.blocksBackgroundWhenInOverlay = true
+        
+        self.presentationDataDisposable = (context.sharedContext.presentationData
+        |> deliverOnMainQueue).start(next: { [weak self] presentationData in
+            if let strongSelf = self {
+                strongSelf.controllerNode.updatePresentationData(presentationData)
+            }
+        })
+        
+        self.idleTimerExtensionDisposable.set(self.context.sharedContext.applicationBindings.pushIdleTimerExtension())
+        
+        self.statusBar.statusBarStyle = .Ignore
+    }
+    
+    required init(coder aDecoder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    
+    deinit {
+        self.presentationDataDisposable?.dispose()
+        self.idleTimerExtensionDisposable.dispose()
+    }
+    
+    override public func loadDisplayNode() {
+        self.displayNode = Node(context: self.context, invite: self.invite)
+        self.controllerNode.dismiss = { [weak self] in
+            self?.presentingViewController?.dismiss(animated: false, completion: nil)
+        }
+        self.controllerNode.cancel = { [weak self] in
+            self?.dismiss()
+        }
+    }
+    
+    override public func loadView() {
+        super.loadView()
+    }
+    
+    override public func viewDidAppear(_ animated: Bool) {
+        super.viewDidAppear(animated)
+        
+        if !self.animatedIn {
+            self.animatedIn = true
+            self.controllerNode.animateIn()
+        }
+    }
+    
+    override public func dismiss(completion: (() -> Void)? = nil) {
+        self.controllerNode.animateOut(completion: completion)
+    }
+    
+    override public func containerLayoutUpdated(_ layout: ContainerViewLayout, transition: ContainedViewLayoutTransition) {
+        super.containerLayoutUpdated(layout, transition: transition)
+        
+        self.controllerNode.containerLayoutUpdated(layout, navigationBarHeight: self.navigationHeight, transition: transition)
+    }
+
+    class Node: ViewControllerTracingNode, UIScrollViewDelegate {
+        private let context: AccountContext
+        private let invite: ExportedInvitation
+        private var presentationData: PresentationData
+    
+        private let dimNode: ASDisplayNode
+        private let wrappingScrollNode: ASScrollNode
+        private let contentContainerNode: ASDisplayNode
+        private let backgroundNode: ASDisplayNode
+        private let contentBackgroundNode: ASDisplayNode
+        private let titleNode: ASTextNode
+        private let subtitleNode: ASTextNode
+        private let cancelButton: HighlightableButtonNode
+        
+        private let textNode: ImmediateTextNode
+        private let qrButtonNode: HighlightTrackingButtonNode
+        private let qrImageNode: TransformImageNode
+        private let qrIconNode: AnimatedStickerNode
+        private var qrCodeSize: Int?
+        private let buttonNode: SolidRoundedButtonNode
+                
+        private var containerLayout: (ContainerViewLayout, CGFloat)?
+        
+        var completion: ((Int32) -> Void)?
+        var dismiss: (() -> Void)?
+        var cancel: (() -> Void)?
+        
+        init(context: AccountContext, invite: ExportedInvitation) {
+            self.context = context
+            self.invite = invite
+            self.presentationData = context.sharedContext.currentPresentationData.with { $0 }
+
+            self.wrappingScrollNode = ASScrollNode()
+            self.wrappingScrollNode.view.alwaysBounceVertical = true
+            self.wrappingScrollNode.view.delaysContentTouches = false
+            self.wrappingScrollNode.view.canCancelContentTouches = true
+            
+            self.dimNode = ASDisplayNode()
+            self.dimNode.backgroundColor = UIColor(white: 0.0, alpha: 0.5)
+            
+            self.contentContainerNode = ASDisplayNode()
+            self.contentContainerNode.isOpaque = false
+
+            self.backgroundNode = ASDisplayNode()
+            self.backgroundNode.clipsToBounds = true
+            self.backgroundNode.cornerRadius = 16.0
+            
+            let backgroundColor = self.presentationData.theme.actionSheet.opaqueItemBackgroundColor
+            let textColor = self.presentationData.theme.actionSheet.primaryTextColor
+            let secondaryTextColor = self.presentationData.theme.actionSheet.secondaryTextColor
+            let accentColor = self.presentationData.theme.actionSheet.controlAccentColor
+            
+            self.contentBackgroundNode = ASDisplayNode()
+            self.contentBackgroundNode.backgroundColor = backgroundColor
+            
+            self.titleNode = ASTextNode()
+            self.titleNode.attributedText = NSAttributedString(string: self.presentationData.strings.InviteLink_QRCode_Title, font: Font.bold(17.0), textColor: textColor)
+            
+            self.subtitleNode = ASTextNode()
+            self.subtitleNode.attributedText = NSAttributedString(string: self.presentationData.strings.InviteLink_QRCode_Title, font: Font.regular(13.0), textColor: secondaryTextColor)
+            
+            self.cancelButton = HighlightableButtonNode()
+            self.cancelButton.setTitle(self.presentationData.strings.Common_Done, with: Font.bold(17.0), with: accentColor, for: .normal)
+            
+            self.buttonNode = SolidRoundedButtonNode(theme: SolidRoundedButtonTheme(theme: self.presentationData.theme), height: 52.0, cornerRadius: 11.0, gloss: false)
+            
+            self.textNode = ImmediateTextNode()
+            self.textNode.maximumNumberOfLines = 3
+            self.textNode.textAlignment = .center
+            
+            self.qrButtonNode = HighlightTrackingButtonNode()
+            self.qrImageNode = TransformImageNode()
+            
+            self.qrIconNode = AnimatedStickerNode()
+            if let path = getAppBundle().path(forResource: "PlaneLogo", ofType: "tgs") {
+                self.qrIconNode.setup(source: AnimatedStickerNodeLocalFileSource(path: path), width: 240, height: 240, mode: .direct(cachePathPrefix: nil))
+                self.qrIconNode.visibility = true
+            }
+            
+            super.init()
+            
+            self.backgroundColor = nil
+            self.isOpaque = false
+            
+            self.dimNode.view.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(self.dimTapGesture(_:))))
+            self.addSubnode(self.dimNode)
+            
+            self.wrappingScrollNode.view.delegate = self
+            self.addSubnode(self.wrappingScrollNode)
+            
+            self.wrappingScrollNode.addSubnode(self.backgroundNode)
+            self.wrappingScrollNode.addSubnode(self.contentContainerNode)
+            
+            self.backgroundNode.addSubnode(self.contentBackgroundNode)
+            self.contentContainerNode.addSubnode(self.titleNode)
+            self.contentContainerNode.addSubnode(self.cancelButton)
+            self.contentContainerNode.addSubnode(self.buttonNode)
+
+            self.contentContainerNode.addSubnode(self.textNode)
+            self.contentContainerNode.addSubnode(self.qrImageNode)
+            self.contentContainerNode.addSubnode(self.qrIconNode)
+            self.contentContainerNode.addSubnode(self.qrButtonNode)
+            
+            let textFont = Font.regular(16.0)
+            
+            self.textNode.attributedText = NSAttributedString(string: self.presentationData.strings.InviteLink_QRCode_Info, font: textFont, textColor: secondaryTextColor)
+            self.buttonNode.title = self.presentationData.strings.InviteLink_QRCode_Share
+            
+            self.cancelButton.addTarget(self, action: #selector(self.cancelButtonPressed), forControlEvents: .touchUpInside)
+            self.buttonNode.pressed = { [weak self] in
+                if let strongSelf = self{
+                    shareQrCode(context: strongSelf.context, link: strongSelf.invite.link)
+                }
+            }
+            
+            self.qrImageNode.setSignal(qrCode(string: self.invite.link, color: .black, backgroundColor: .white, icon: .cutout) |> beforeNext { [weak self] size, _ in
+                guard let strongSelf = self else {
+                    return
+                }
+                strongSelf.qrCodeSize = size
+                if let (layout, navigationHeight) = strongSelf.containerLayout {
+                    strongSelf.containerLayoutUpdated(layout, navigationBarHeight: navigationHeight, transition: .immediate)
+                }
+            } |> map { $0.1 }, attemptSynchronously: true)
+            
+            self.qrButtonNode.addTarget(self, action: #selector(self.qrPressed), forControlEvents: .touchUpInside)
+            self.qrButtonNode.highligthedChanged = { [weak self] highlighted in
+                guard let strongSelf = self else {
+                    return
+                }
+                if highlighted {
+                    strongSelf.qrImageNode.alpha = 0.4
+                    strongSelf.qrIconNode.alpha = 0.4
+                } else {
+                    strongSelf.qrImageNode.layer.animateAlpha(from: strongSelf.qrImageNode.alpha, to: 1.0, duration: 0.2)
+                    strongSelf.qrImageNode.alpha = 1.0
+                    strongSelf.qrIconNode.layer.animateAlpha(from: strongSelf.qrIconNode.alpha, to: 1.0, duration: 0.2)
+                    strongSelf.qrIconNode.alpha = 1.0
+                }
+            }
+        }
+        
+        @objc private func qrPressed() {
+            shareQrCode(context: self.context, link: self.invite.link)
+        }
+        
+        func updatePresentationData(_ presentationData: PresentationData) {
+            let previousTheme = self.presentationData.theme
+            self.presentationData = presentationData
+            
+            self.contentBackgroundNode.backgroundColor = self.presentationData.theme.actionSheet.opaqueItemBackgroundColor
+            self.titleNode.attributedText = NSAttributedString(string: self.titleNode.attributedText?.string ?? "", font: Font.bold(17.0), textColor: self.presentationData.theme.actionSheet.primaryTextColor)
+            
+            if previousTheme !== presentationData.theme, let (layout, navigationBarHeight) = self.containerLayout {
+                self.containerLayoutUpdated(layout, navigationBarHeight: navigationBarHeight, transition: .immediate)
+            }
+            
+            self.cancelButton.setTitle(self.presentationData.strings.Common_Done, with: Font.bold(17.0), with: self.presentationData.theme.actionSheet.controlAccentColor, for: .normal)
+            self.buttonNode.updateTheme(SolidRoundedButtonTheme(theme: self.presentationData.theme))
+        }
+        
+        override func didLoad() {
+            super.didLoad()
+            
+            if #available(iOSApplicationExtension 11.0, iOS 11.0, *) {
+                self.wrappingScrollNode.view.contentInsetAdjustmentBehavior = .never
+            }
+        }
+        
+        @objc func cancelButtonPressed() {
+            self.cancel?()
+        }
+        
+        @objc func dimTapGesture(_ recognizer: UITapGestureRecognizer) {
+            if case .ended = recognizer.state {
+                self.cancelButtonPressed()
+            }
+        }
+        
+        func animateIn() {
+            self.dimNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+            
+            let offset = self.bounds.size.height - self.contentBackgroundNode.frame.minY
+            
+            let dimPosition = self.dimNode.layer.position
+            self.dimNode.layer.animatePosition(from: CGPoint(x: dimPosition.x, y: dimPosition.y - offset), to: dimPosition, duration: 0.3, timingFunction: kCAMediaTimingFunctionSpring)
+            self.layer.animateBoundsOriginYAdditive(from: -offset, to: 0.0, duration: 0.3, timingFunction: kCAMediaTimingFunctionSpring)
+        }
+        
+        func animateOut(completion: (() -> Void)? = nil) {
+            var dimCompleted = false
+            var offsetCompleted = false
+            
+            let internalCompletion: () -> Void = { [weak self] in
+                if let strongSelf = self, dimCompleted && offsetCompleted {
+                    strongSelf.dismiss?()
+                }
+                completion?()
+            }
+            
+            self.dimNode.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.3, removeOnCompletion: false, completion: { _ in
+                dimCompleted = true
+                internalCompletion()
+            })
+            
+            let offset = self.bounds.size.height - self.contentBackgroundNode.frame.minY
+            let dimPosition = self.dimNode.layer.position
+            self.dimNode.layer.animatePosition(from: dimPosition, to: CGPoint(x: dimPosition.x, y: dimPosition.y - offset), duration: 0.3, timingFunction: kCAMediaTimingFunctionSpring, removeOnCompletion: false)
+            self.layer.animateBoundsOriginYAdditive(from: 0.0, to: -offset, duration: 0.3, timingFunction: kCAMediaTimingFunctionSpring, removeOnCompletion: false, completion: { _ in
+                offsetCompleted = true
+                internalCompletion()
+            })
+        }
+        
+        override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+            if self.bounds.contains(point) {
+                if !self.contentBackgroundNode.bounds.contains(self.convert(point, to: self.contentBackgroundNode)) {
+                    return self.dimNode.view
+                }
+            }
+            return super.hitTest(point, with: event)
+        }
+        
+        func scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerate: Bool) {
+            let contentOffset = scrollView.contentOffset
+            let additionalTopHeight = max(0.0, -contentOffset.y)
+            
+            if additionalTopHeight >= 30.0 {
+                self.cancelButtonPressed()
+            }
+        }
+        
+        func containerLayoutUpdated(_ layout: ContainerViewLayout, navigationBarHeight: CGFloat, transition: ContainedViewLayoutTransition) {
+            self.containerLayout = (layout, navigationBarHeight)
+            
+            var insets = layout.insets(options: [.statusBar, .input])
+            let cleanInsets = layout.insets(options: [.statusBar])
+            insets.top = max(10.0, insets.top)
+            
+            let makeImageLayout = self.qrImageNode.asyncLayout()
+            let imageSide: CGFloat = 240.0
+            let imageSize = CGSize(width: imageSide, height: imageSide)
+            let imageApply = makeImageLayout(TransformImageArguments(corners: ImageCorners(), imageSize: imageSize, boundingSize: imageSize, intrinsicInsets: UIEdgeInsets(), emptyColor: nil))
+            
+            let _ = imageApply()
+            
+            let imageFrame = CGRect(origin: CGPoint(x: floor((layout.size.width - imageSize.width) / 2.0), y: insets.top + 24.0), size: imageSize)
+            transition.updateFrame(node: self.qrImageNode, frame: imageFrame)
+            transition.updateFrame(node: self.qrButtonNode, frame: imageFrame)
+            
+            if let qrCodeSize = self.qrCodeSize {
+                let (_, cutoutFrame, _) = qrCodeCutout(size: qrCodeSize, dimensions: imageSize, scale: nil)
+                self.qrIconNode.updateLayout(size: cutoutFrame.size)
+                transition.updateBounds(node: self.qrIconNode, bounds: CGRect(origin: CGPoint(), size: cutoutFrame.size))
+                transition.updatePosition(node: self.qrIconNode, position: imageFrame.center.offsetBy(dx: 0.0, dy: -1.0))
+            }
+            
+            let inset: CGFloat = 22.0
+            let textSize = self.textNode.updateLayout(CGSize(width: layout.size.width - inset * 2.0, height: CGFloat.greatestFiniteMagnitude))
+            let textFrame = CGRect(origin: CGPoint(x: floor((layout.size.width - textSize.width) / 2.0), y: imageFrame.maxX + 20.0), size: textSize)
+            transition.updateFrame(node: self.textNode, frame: textFrame)
+            
+            let buttonSideInset: CGFloat = 16.0
+            let bottomInset = insets.bottom + 10.0
+            let buttonWidth = layout.size.width - buttonSideInset * 2.0
+            let buttonHeight: CGFloat = 50.0
+            
+            let buttonFrame = CGRect(origin: CGPoint(x: floor((layout.size.width - buttonWidth) / 2.0), y: layout.size.height - bottomInset - buttonHeight), size: CGSize(width: buttonWidth, height: buttonHeight))
+            transition.updateFrame(node: self.buttonNode, frame: buttonFrame)
+            let _ = self.buttonNode.updateLayout(width: buttonFrame.width, transition: transition)
+            
+            
+            let titleHeight: CGFloat = 54.0
+            let contentHeight = titleHeight + textSize.height + imageSize.height + bottomInset + 52.0 + 77.0
+            
+            let width = horizontalContainerFillingSizeForLayout(layout: layout, sideInset: layout.safeInsets.left)
+            
+            let sideInset = floor((layout.size.width - width) / 2.0)
+            let contentContainerFrame = CGRect(origin: CGPoint(x: sideInset, y: layout.size.height - contentHeight), size: CGSize(width: width, height: contentHeight))
+            let contentFrame = contentContainerFrame
+            
+            var backgroundFrame = CGRect(origin: CGPoint(x: contentFrame.minX, y: contentFrame.minY), size: CGSize(width: contentFrame.width, height: contentFrame.height + 2000.0))
+            if backgroundFrame.minY < contentFrame.minY {
+                backgroundFrame.origin.y = contentFrame.minY
+            }
+            transition.updateFrame(node: self.backgroundNode, frame: backgroundFrame)
+            transition.updateFrame(node: self.contentBackgroundNode, frame: CGRect(origin: CGPoint(), size: backgroundFrame.size))
+            transition.updateFrame(node: self.wrappingScrollNode, frame: CGRect(origin: CGPoint(), size: layout.size))
+            transition.updateFrame(node: self.dimNode, frame: CGRect(origin: CGPoint(), size: layout.size))
+            
+            let titleSize = self.titleNode.measure(CGSize(width: width, height: titleHeight))
+            let titleFrame = CGRect(origin: CGPoint(x: floor((contentFrame.width - titleSize.width) / 2.0), y: 16.0), size: titleSize)
+            transition.updateFrame(node: self.titleNode, frame: titleFrame)
+            
+            let cancelSize = self.cancelButton.measure(CGSize(width: width, height: titleHeight))
+            let cancelFrame = CGRect(origin: CGPoint(x: width - cancelSize.width - 16.0, y: 16.0), size: cancelSize)
+            transition.updateFrame(node: self.cancelButton, frame: cancelFrame)
+            
+            let buttonInset: CGFloat = 16.0
+            let doneButtonHeight = self.buttonNode.updateLayout(width: contentFrame.width - buttonInset * 2.0, transition: transition)
+            transition.updateFrame(node: self.buttonNode, frame: CGRect(x: buttonInset, y: contentHeight - doneButtonHeight - insets.bottom - 16.0, width: contentFrame.width, height: doneButtonHeight))
+            
+            transition.updateFrame(node: self.contentContainerNode, frame: contentContainerFrame)
+        }
+    }
+}

submodules/InviteLinksUI/Sources/InviteLinkViewController.swift

@@ -0,0 +1,766 @@
+import Foundation
+import UIKit
+import SwiftSignalKit
+import TelegramPresentationData
+import AppBundle
+import AsyncDisplayKit
+import Postbox
+import SyncCore
+import TelegramCore
+import Display
+import AccountContext
+import SolidRoundedButtonNode
+import ItemListUI
+import ItemListPeerItem
+import SectionHeaderItem
+import TelegramStringFormatting
+import MergeLists
+import ContextUI
+import ShareController
+import OverlayStatusController
+import PresentationDataUtils
+import DirectionalPanGesture
+
+class InviteLinkViewInteraction {
+    let context: AccountContext
+    let openPeer: (PeerId) -> Void
+    let shareLink: (ExportedInvitation) -> Void
+    let contextAction: (ExportedInvitation, ASDisplayNode, ContextGesture?) -> Void
+    
+    init(context: AccountContext, openPeer: @escaping (PeerId) -> Void, shareLink: @escaping (ExportedInvitation) -> Void, contextAction: @escaping (ExportedInvitation, ASDisplayNode, ContextGesture?) -> Void) {
+        self.context = context
+        self.openPeer = openPeer
+        self.shareLink = shareLink
+        self.contextAction = contextAction
+    }
+}
+
+private struct InviteLinkViewTransaction {
+    let deletions: [ListViewDeleteItem]
+    let insertions: [ListViewInsertItem]
+    let updates: [ListViewUpdateItem]
+    let isLoading: Bool
+}
+
+private enum InviteLinkViewEntryId: Hashable {
+    case link
+    case creatorHeader
+    case creator
+    case importerHeader
+    case importer(PeerId)
+}
+
+private func color(for invite: ExportedInvitation) -> UIColor? {
+    let color: UIColor?
+    let availability = invitationAvailability(invite)
+    if invite.isRevoked {
+        color = nil
+    } else if invite.expireDate == nil && invite.usageLimit == nil {
+        color = nil
+    } else if availability >= 0.5 {
+        color = UIColor(rgb: 0x4aca62)
+    } else if availability > 0.0 {
+        color = UIColor(rgb: 0xf8a953)
+    } else {
+        color = UIColor(rgb: 0xf2656a)
+    }
+    return color
+}
+
+private enum InviteLinkViewEntry: Comparable, Identifiable {
+    case link(PresentationTheme, ExportedInvitation)
+    case creatorHeader(PresentationTheme, String)
+    case creator(PresentationTheme, PresentationDateTimeFormat, Peer, Int32)
+    case importerHeader(PresentationTheme, String)
+    case importer(Int32, PresentationTheme, PresentationDateTimeFormat, Peer, Int32)
+    
+    var stableId: InviteLinkViewEntryId {
+        switch self {
+            case .link:
+                return .link
+            case .creatorHeader:
+                return .creatorHeader
+            case .creator:
+                return .creator
+            case .importerHeader:
+                return .importerHeader
+            case let .importer(_, _, _, peer, _):
+                return .importer(peer.id)
+        }
+    }
+    
+    static func ==(lhs: InviteLinkViewEntry, rhs: InviteLinkViewEntry) -> Bool {
+        switch lhs {
+            case let .link(lhsTheme, lhsInvitation):
+                if case let .link(rhsTheme, rhsInvitation) = rhs, lhsTheme === rhsTheme, lhsInvitation == rhsInvitation {
+                    return true
+                } else {
+                    return false
+                }
+            case let .creatorHeader(lhsTheme, lhsTitle):
+                if case let .creatorHeader(rhsTheme, rhsTitle) = rhs, lhsTheme === rhsTheme, lhsTitle == rhsTitle {
+                    return true
+                } else {
+                    return false
+                }
+            case let .creator(lhsTheme, lhsDateTimeFormat, lhsPeer, lhsDate):
+                if case let .creator(rhsTheme, rhsDateTimeFormat, rhsPeer, rhsDate) = rhs, lhsTheme === rhsTheme, lhsDateTimeFormat == rhsDateTimeFormat, arePeersEqual(lhsPeer, rhsPeer), lhsDate == rhsDate {
+                    return true
+                } else {
+                    return false
+                }
+            case let .importerHeader(lhsTheme, lhsTitle):
+                if case let .importerHeader(rhsTheme, rhsTitle) = rhs, lhsTheme === rhsTheme, lhsTitle == rhsTitle {
+                    return true
+                } else {
+                    return false
+                }
+            case let .importer(lhsIndex, lhsTheme, lhsDateTimeFormat, lhsPeer, lhsDate):
+                if case let .importer(rhsIndex, rhsTheme, rhsDateTimeFormat, rhsPeer, rhsDate) = rhs, lhsIndex == rhsIndex, lhsTheme === rhsTheme, lhsDateTimeFormat == rhsDateTimeFormat, arePeersEqual(lhsPeer, rhsPeer), lhsDate == rhsDate {
+                    return true
+                } else {
+                    return false
+                }
+        }
+    }
+    
+    static func <(lhs: InviteLinkViewEntry, rhs: InviteLinkViewEntry) -> Bool {
+        switch lhs {
+            case .link:
+                switch rhs {
+                    case .link:
+                        return false
+                    case .creatorHeader, .creator, .importerHeader, .importer:
+                        return true
+                }
+            case .creatorHeader:
+                switch rhs {
+                    case .link, .creatorHeader:
+                        return false
+                    case .creator, .importerHeader, .importer:
+                        return true
+                }
+            case .creator:
+                switch rhs {
+                    case .link, .creatorHeader, .creator:
+                        return false
+                    case .importerHeader, .importer:
+                        return true
+            }
+            case .importerHeader:
+                switch rhs {
+                    case .link, .creatorHeader, .importerHeader:
+                        return false
+                    case .creator, .importer:
+                        return true
+                }
+            case let .importer(lhsIndex, _, _, _, _):
+                switch rhs {
+                    case .link, .creatorHeader, .creator, .importerHeader:
+                        return false
+                    case let .importer(rhsIndex, _, _, _, _):
+                        return lhsIndex < rhsIndex
+                }
+        }
+    }
+    
+    func item(account: Account, presentationData: PresentationData, interaction: InviteLinkViewInteraction) -> ListViewItem {
+        switch self {
+            case let .link(_, invite):
+                let buttonColor = color(for: invite)
+                return ItemListPermanentInviteLinkItem(context: interaction.context, presentationData: ItemListPresentationData(presentationData), invite: invite, peers: [], buttonColor: buttonColor, sectionId: 0, style: .plain, shareAction: {
+                    interaction.shareLink(invite)
+                }, contextAction: { node in
+                    interaction.contextAction(invite, node, nil)
+                }, viewAction: {
+                })
+            case let .creatorHeader(_, title):
+                return SectionHeaderItem(presentationData: ItemListPresentationData(presentationData), title: title)
+            case let .creator(_, dateTimeFormat, peer, date):
+                let dateString = stringForFullDate(timestamp: date, strings: presentationData.strings, dateTimeFormat: dateTimeFormat)
+                return ItemListPeerItem(presentationData: ItemListPresentationData(presentationData), dateTimeFormat: dateTimeFormat, nameDisplayOrder: presentationData.nameDisplayOrder, context: interaction.context, peer: peer, height: .generic, nameStyle: .distinctBold, presence: nil, text: .text(dateString, .secondary), label: .none, editing: ItemListPeerItemEditing(editable: false, editing: false, revealed: false), revealOptions: nil, switchValue: nil, enabled: true, selectable: true, sectionId: 0, action: {
+                    interaction.openPeer(peer.id)
+                }, setPeerIdWithRevealedOptions: { _, _ in }, removePeer: { _ in }, hasTopStripe: false, noInsets: true, tag: nil)
+            case let .importerHeader(_, title):
+                return SectionHeaderItem(presentationData: ItemListPresentationData(presentationData), title: title)
+            case let .importer(_, _, dateTimeFormat, peer, date):
+                let dateString = stringForFullDate(timestamp: date, strings: presentationData.strings, dateTimeFormat: dateTimeFormat)
+                return ItemListPeerItem(presentationData: ItemListPresentationData(presentationData), dateTimeFormat: dateTimeFormat, nameDisplayOrder: presentationData.nameDisplayOrder, context: interaction.context, peer: peer, height: .generic, nameStyle: .distinctBold, presence: nil, text: .text(dateString, .secondary), label: .none, editing: ItemListPeerItemEditing(editable: false, editing: false, revealed: false), revealOptions: nil, switchValue: nil, enabled: true, selectable: true, sectionId: 0, action: {
+                    interaction.openPeer(peer.id)
+                }, setPeerIdWithRevealedOptions: { _, _ in }, removePeer: { _ in }, hasTopStripe: false, noInsets: true, tag: nil)
+        }
+    }
+}
+
+private func preparedTransition(from fromEntries: [InviteLinkViewEntry], to toEntries: [InviteLinkViewEntry], isLoading: Bool, account: Account, presentationData: PresentationData, interaction: InviteLinkViewInteraction) -> InviteLinkViewTransaction {
+    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(account: account, presentationData: presentationData, interaction: interaction), directionHint: nil) }
+    let updates = updateIndices.map { ListViewUpdateItem(index: $0.0, previousIndex: $0.2, item: $0.1.item(account: account, presentationData: presentationData, interaction: interaction), directionHint: nil) }
+    
+    return InviteLinkViewTransaction(deletions: deletions, insertions: insertions, updates: updates, isLoading: isLoading)
+}
+
+public final class InviteLinkViewController: ViewController {
+    private var controllerNode: Node {
+        return self.displayNode as! Node
+    }
+    
+    private var animatedIn = false
+    
+    private let context: AccountContext
+    private let peerId: PeerId
+    private let invite: ExportedInvitation
+    private let importersContext: PeerInvitationImportersContext?
+
+    private var presentationDataDisposable: Disposable?
+            
+    public init(context: AccountContext, peerId: PeerId, invite: ExportedInvitation, importersContext: PeerInvitationImportersContext?) {
+        self.context = context
+        self.peerId = peerId
+        self.invite = invite
+        self.importersContext = importersContext
+                
+        super.init(navigationBarPresentationData: nil)
+        
+        self.navigationPresentation = .flatModal
+        self.statusBar.statusBarStyle = .Ignore
+        
+        self.blocksBackgroundWhenInOverlay = true
+        
+        self.presentationDataDisposable = (context.sharedContext.presentationData
+        |> deliverOnMainQueue).start(next: { [weak self] presentationData in
+            if let strongSelf = self {
+                strongSelf.controllerNode.updatePresentationData(presentationData)
+            }
+        })
+        
+        self.statusBar.statusBarStyle = .Ignore
+    }
+    
+    required init(coder aDecoder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    
+    deinit {
+        self.presentationDataDisposable?.dispose()
+    }
+    
+    override public func loadDisplayNode() {
+        self.displayNode = Node(context: self.context, peerId: self.peerId, invite: self.invite, importersContext: self.importersContext, controller: self)
+    }
+    
+    override public func loadView() {
+        super.loadView()
+    }
+    
+    private var didAppearOnce: Bool = false
+    private var isDismissed: Bool = false
+    public override func viewDidAppear(_ animated: Bool) {
+        super.viewDidAppear(animated)
+        
+        if !self.didAppearOnce {
+            self.didAppearOnce = true
+            
+            self.controllerNode.animateIn()
+        }
+    }
+    
+    override public func dismiss(completion: (() -> Void)? = nil) {
+        if !self.isDismissed {
+            self.isDismissed = true
+            self.didAppearOnce = false
+            
+            self.controllerNode.animateOut(completion: { [weak self] in
+                completion?()
+                self?.dismiss(animated: false)
+            })
+        }
+    }
+    
+    override public func containerLayoutUpdated(_ layout: ContainerViewLayout, transition: ContainedViewLayoutTransition) {
+        super.containerLayoutUpdated(layout, transition: transition)
+        
+        self.controllerNode.containerLayoutUpdated(layout, transition: transition)
+    }
+
+    class Node: ViewControllerTracingNode, UIGestureRecognizerDelegate {
+        private weak var controller: InviteLinkViewController?
+        
+        private let context: AccountContext
+        private let peerId: PeerId
+        private let invite: ExportedInvitation
+        
+        private var interaction: InviteLinkViewInteraction?
+        
+        private var presentationData: PresentationData
+        private let presentationDataPromise: Promise<PresentationData>
+                
+        private var disposable: Disposable?
+        
+        private let dimNode: ASDisplayNode
+        private let contentNode: ASDisplayNode
+        private let headerNode: ASDisplayNode
+        private let headerBackgroundNode: ASDisplayNode
+        private let titleNode: ImmediateTextNode
+        private let subtitleNode: ImmediateTextNode
+        private let editButton: HighlightableButtonNode
+        private let doneButton: HighlightableButtonNode
+        private let historyBackgroundNode: ASDisplayNode
+        private let historyBackgroundContentNode: ASDisplayNode
+        private var floatingHeaderOffset: CGFloat?
+        private let listNode: ListView
+        
+        private var enqueuedTransitions: [InviteLinkViewTransaction] = []
+        
+        private var validLayout: ContainerViewLayout?
+        
+        private var presentationDataDisposable: Disposable?
+        
+        private let importersContext: PeerInvitationImportersContext
+        
+        init(context: AccountContext, peerId: PeerId, invite: ExportedInvitation, importersContext: PeerInvitationImportersContext?, controller: InviteLinkViewController) {
+            self.context = context
+            self.peerId = peerId
+            self.invite = invite
+            let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+            self.presentationData = presentationData
+            self.presentationDataPromise = Promise(self.presentationData)
+            self.controller = controller
+            
+            self.importersContext = importersContext ?? PeerInvitationImportersContext(account: context.account, peerId: peerId, invite: invite)
+            
+            self.dimNode = ASDisplayNode()
+            self.dimNode.backgroundColor = UIColor(white: 0.0, alpha: 0.5)
+            
+            self.contentNode = ASDisplayNode()
+            
+            self.headerNode = ASDisplayNode()
+            self.headerNode.clipsToBounds = true
+            
+            self.headerBackgroundNode = ASDisplayNode()
+            self.headerBackgroundNode.backgroundColor = self.presentationData.theme.list.plainBackgroundColor
+            self.headerBackgroundNode.cornerRadius = 16.0
+            
+            self.titleNode = ImmediateTextNode()
+            self.titleNode.maximumNumberOfLines = 1
+            self.titleNode.textAlignment = .center
+            self.titleNode.attributedText = NSAttributedString(string: self.presentationData.strings.InviteLink_InviteLink, font: Font.bold(17.0), textColor: self.presentationData.theme.actionSheet.primaryTextColor)
+            
+            self.subtitleNode = ImmediateTextNode()
+            self.subtitleNode.maximumNumberOfLines = 1
+            self.subtitleNode.textAlignment = .center
+            
+            let buttonColor = color(for: invite) ?? presentationData.theme.actionSheet.controlAccentColor
+            
+            self.editButton = HighlightableButtonNode()
+            self.editButton.setTitle(self.presentationData.strings.Common_Edit, with: Font.regular(17.0), with: buttonColor, for: .normal)
+            
+            self.doneButton = HighlightableButtonNode()
+            self.doneButton.setTitle(self.presentationData.strings.Common_Done, with: Font.bold(17.0), with: buttonColor, for: .normal)
+            
+            self.historyBackgroundNode = ASDisplayNode()
+            self.historyBackgroundNode.isLayerBacked = true
+            
+            self.historyBackgroundContentNode = ASDisplayNode()
+            self.historyBackgroundContentNode.isLayerBacked = true
+            self.historyBackgroundContentNode.backgroundColor = self.presentationData.theme.list.plainBackgroundColor
+            
+            self.historyBackgroundNode.addSubnode(self.historyBackgroundContentNode)
+            
+            self.listNode = ListView()
+            self.listNode.verticalScrollIndicatorColor = UIColor(white: 0.0, alpha: 0.3)
+            self.listNode.verticalScrollIndicatorFollowsOverscroll = true
+            
+            super.init()
+            
+            self.backgroundColor = nil
+            self.isOpaque = false
+        
+            self.interaction = InviteLinkViewInteraction(context: context, openPeer: { [weak self] peerId in
+                if let strongSelf = self, let navigationController = strongSelf.controller?.navigationController as? NavigationController {
+                    context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: context, chatLocation: .peer(peerId), keepStack: .always))
+                }
+            }, shareLink: { [weak self] invite in
+                let shareController = ShareController(context: context, subject: .url(invite.link))
+                self?.controller?.present(shareController, in: .window(.root))
+            }, contextAction: { [weak self] invite, node, gesture in
+                guard let node = node as? ContextExtractedContentContainingNode else {
+                    return
+                }
+                
+                let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+                var items: [ContextMenuItem] = []
+
+                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: { [weak self] _, f in
+                    f(.dismissWithoutContent)
+                    
+                    UIPasteboard.general.string = invite.link
+                    let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+                    self?.controller?.present(OverlayStatusController(theme: presentationData.theme, type: .genericSuccess(presentationData.strings.Username_LinkCopied, false)), in: .window(.root))
+                })))
+                
+                if !invite.isRevoked {
+                    items.append(.action(ContextMenuActionItem(text: presentationData.strings.InviteLink_ContextGetQRCode, icon: { theme in
+                        return generateTintedImage(image: UIImage(bundleImageName: "Wallet/QrIcon"), color: theme.contextMenu.primaryColor)
+                    }, action: { [weak self] _, f in
+                        f(.dismissWithoutContent)
+                        
+                        let controller = InviteLinkQRCodeController(context: context, invite: invite)
+                        self?.controller?.present(controller, in: .window(.root))
+                    })))
+                }
+                                
+                let contextController = ContextController(account: context.account, presentationData: presentationData, source: .extracted(InviteLinkContextExtractedContentSource(controller: controller, sourceNode: node)), items: .single(items), reactionItems: [], gesture: gesture)
+                self?.controller?.presentInGlobalOverlay(contextController)
+            })
+            
+            let previousEntries = Atomic<[InviteLinkViewEntry]?>(value: nil)
+            
+            let creatorPeer = context.account.postbox.loadedPeerWithId(invite.adminId)
+            self.disposable = (combineLatest(self.presentationDataPromise.get(), self.importersContext.state, creatorPeer)
+            |> deliverOnMainQueue).start(next: { [weak self] presentationData, state, creatorPeer in
+                if let strongSelf = self {
+                    var entries: [InviteLinkViewEntry] = []
+                    
+                    entries.append(.link(presentationData.theme, invite))
+                    entries.append(.creatorHeader(presentationData.theme, presentationData.strings.InviteLink_CreatedBy.uppercased()))
+                    entries.append(.creator(presentationData.theme, presentationData.dateTimeFormat, creatorPeer, invite.date))
+                    
+                    if !state.importers.isEmpty {
+                        entries.append(.importerHeader(presentationData.theme, presentationData.strings.InviteLink_PeopleJoined(Int32(state.count)).uppercased()))
+                    }
+                    
+                    var index: Int32 = 0
+                    for importer in state.importers {
+                        if let peer = importer.peer.peer {
+                            entries.append(.importer(index, presentationData.theme, presentationData.dateTimeFormat, peer, importer.date))
+                        }
+                        index += 1
+                    }
+                    
+                    let previousEntries = previousEntries.swap(entries)
+                    
+                    let transition = preparedTransition(from: previousEntries ?? [], to: entries, isLoading: false, account: context.account, presentationData: presentationData, interaction: strongSelf.interaction!)
+                    strongSelf.enqueueTransition(transition)
+                }
+            })
+            
+            self.listNode.preloadPages = true
+            self.listNode.stackFromBottom = true
+            self.listNode.updateFloatingHeaderOffset = { [weak self] offset, transition in
+                if let strongSelf = self {
+                    strongSelf.updateFloatingHeaderOffset(offset: offset, transition: transition)
+                }
+            }
+            self.listNode.visibleBottomContentOffsetChanged = { [weak self] offset in
+                if case let .known(value) = offset, value < 40.0 {
+                    self?.importersContext.loadMore()
+                }
+            }
+            
+            self.addSubnode(self.dimNode)
+            self.addSubnode(self.contentNode)
+            self.contentNode.addSubnode(self.historyBackgroundNode)
+            self.contentNode.addSubnode(self.listNode)
+            self.contentNode.addSubnode(self.headerNode)
+            
+            self.headerNode.addSubnode(self.headerBackgroundNode)
+            self.headerNode.addSubnode(self.titleNode)
+            self.headerNode.addSubnode(self.subtitleNode)
+            self.headerNode.addSubnode(self.editButton)
+            self.headerNode.addSubnode(self.doneButton)
+            
+            self.editButton.addTarget(self, action: #selector(self.editButtonPressed), forControlEvents: .touchUpInside)
+            self.doneButton.addTarget(self, action: #selector(self.doneButtonPressed), forControlEvents: .touchUpInside)
+            
+            self.presentationDataDisposable = context.sharedContext.presentationData.start(next: { [weak self] presentationData in
+                if let strongSelf = self {
+                    if strongSelf.presentationData.theme !== presentationData.theme || strongSelf.presentationData.strings !== presentationData.strings {
+                        strongSelf.updatePresentationData(presentationData)
+                    }
+                }
+            })
+            
+            if invite.isRevoked {
+                self.editButton.isHidden = true
+            }
+        }
+        
+        deinit {
+            self.disposable?.dispose()
+            self.presentationDataDisposable?.dispose()
+        }
+        
+        override func didLoad() {
+            super.didLoad()
+            
+            self.view.disablesInteractiveTransitionGestureRecognizer = true
+            self.view.disablesInteractiveModalDismiss = true
+            
+            self.dimNode.view.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(self.dimTapGesture(_:))))
+            
+            let panRecognizer = DirectionalPanGestureRecognizer(target: self, action: #selector(self.panGesture(_:)))
+            panRecognizer.delegate = self
+            panRecognizer.delaysTouchesBegan = false
+            panRecognizer.cancelsTouchesInView = true
+            self.view.addGestureRecognizer(panRecognizer)
+        }
+        
+        @objc private func editButtonPressed() {
+            let navigationController = self.controller?.navigationController as? NavigationController
+            self.controller?.dismiss()
+            
+            if let navigationController = navigationController {
+                let controller = inviteLinkEditController(context: self.context, peerId: self.peerId, invite: self.invite)
+                controller.navigationPresentation = .modal
+                navigationController.pushViewController(controller)
+            }
+        }
+        
+        @objc private func doneButtonPressed() {
+            self.controller?.dismiss()
+        }
+        
+        func updatePresentationData(_ presentationData: PresentationData) {
+            self.presentationData = presentationData
+            self.presentationDataPromise.set(.single(presentationData))
+            
+            self.historyBackgroundContentNode.backgroundColor = self.presentationData.theme.list.plainBackgroundColor
+            self.headerBackgroundNode.backgroundColor = self.presentationData.theme.list.plainBackgroundColor
+            self.titleNode.attributedText = NSAttributedString(string: self.presentationData.strings.InviteLink_InviteLink, font: Font.bold(17.0), textColor: self.presentationData.theme.actionSheet.primaryTextColor)
+            
+            let buttonColor = color(for: invite) ?? self.presentationData.theme.actionSheet.controlAccentColor
+            self.editButton.setTitle(self.presentationData.strings.Common_Edit, with: Font.regular(17.0), with: buttonColor, for: .normal)
+            self.doneButton.setTitle(self.presentationData.strings.Common_Done, with: Font.bold(17.0), with: buttonColor, for: .normal)
+        }
+        
+        private func enqueueTransition(_ transition: InviteLinkViewTransaction) {
+            self.enqueuedTransitions.append(transition)
+            
+            if let _ = self.validLayout {
+                while !self.enqueuedTransitions.isEmpty {
+                    self.dequeueTransition()
+                }
+            }
+        }
+        
+        private func dequeueTransition() {
+            guard let _ = self.validLayout, let transition = self.enqueuedTransitions.first else {
+                return
+            }
+            self.enqueuedTransitions.remove(at: 0)
+            
+            self.listNode.transaction(deleteIndices: transition.deletions, insertIndicesAndItems: transition.insertions, updateIndicesAndItems: transition.updates, options: ListViewDeleteAndInsertOptions(), updateSizeAndInsets: nil, updateOpaqueState: nil, completion: { _ in
+            })
+        }
+        
+        func animateIn() {
+            guard let layout = self.validLayout else {
+                return
+            }
+            let transition = ContainedViewLayoutTransition.animated(duration: 0.4, curve: .spring)
+            
+            let initialBounds = self.contentNode.bounds
+            self.contentNode.bounds = initialBounds.offsetBy(dx: 0.0, dy: -layout.size.height)
+            transition.animateView({
+                self.contentNode.view.bounds = initialBounds
+            })
+            self.dimNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.3)
+        }
+        
+        func animateOut(completion: (() -> Void)?) {
+            guard let layout = self.validLayout else {
+                return
+            }
+            var offsetCompleted = false
+            let internalCompletion: () -> Void = {
+                if offsetCompleted {
+                    completion?()
+                }
+            }
+            
+            self.contentNode.layer.animateBoundsOriginYAdditive(from: self.contentNode.bounds.origin.y, to: -layout.size.height, duration: 0.3, timingFunction: kCAMediaTimingFunctionSpring, removeOnCompletion: false, completion: { _ in
+                offsetCompleted = true
+                internalCompletion()
+            })
+            self.dimNode.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.2, removeOnCompletion: false)
+        }
+        
+        func containerLayoutUpdated(_ layout: ContainerViewLayout, transition: ContainedViewLayoutTransition) {
+            self.validLayout = layout
+            
+            transition.updateFrame(node: self.dimNode, frame: CGRect(origin: CGPoint(), size: layout.size))
+            transition.updateFrame(node: self.contentNode, frame: CGRect(origin: CGPoint(), size: layout.size))
+            
+            var insets = UIEdgeInsets()
+            insets.left = layout.safeInsets.left
+            insets.right = layout.safeInsets.right
+            insets.bottom = layout.intrinsicInsets.bottom
+                    
+            let headerHeight: CGFloat = 54.0
+            let visibleItemsHeight: CGFloat = 147.0 + floor(52.0 * 3.5)
+        
+            let layoutTopInset: CGFloat = max(layout.statusBarHeight ?? 0.0, layout.safeInsets.top)
+            
+            let listTopInset = layoutTopInset + headerHeight
+            let listNodeSize = CGSize(width: layout.size.width, height: layout.size.height - listTopInset)
+            
+            insets.top = max(0.0, listNodeSize.height - visibleItemsHeight)
+                        
+            let (duration, curve) = listViewAnimationDurationAndCurve(transition: transition)
+            let updateSizeAndInsets = ListViewUpdateSizeAndInsets(size: listNodeSize, insets: insets, duration: duration, curve: curve)
+            self.listNode.transaction(deleteIndices: [], insertIndicesAndItems: [], updateIndicesAndItems: [], options: [.Synchronous, .LowLatency], scrollToItem: nil, updateSizeAndInsets: updateSizeAndInsets, stationaryItemRange: nil, updateOpaqueState: nil, completion: { _ in })
+            
+            transition.updateFrame(node: self.listNode, frame: CGRect(origin: CGPoint(x: 0.0, y: listTopInset), size: listNodeSize))
+            
+            transition.updateFrame(node: self.headerBackgroundNode, frame: CGRect(x: 0.0, y: 0.0, width: layout.size.width, height: 68.0))
+            
+            let titleSize = self.titleNode.updateLayout(CGSize(width: layout.size.width, height: headerHeight))
+            let titleFrame = CGRect(origin: CGPoint(x: floor((layout.size.width - titleSize.width) / 2.0), y: 18.0), size: titleSize)
+            transition.updateFrame(node: self.titleNode, frame: titleFrame)
+            
+            let editSize = self.editButton.measure(CGSize(width: layout.size.width, height: headerHeight))
+            let editFrame = CGRect(origin: CGPoint(x: 16.0, y: 18.0), size: editSize)
+            transition.updateFrame(node: self.editButton, frame: editFrame)
+            
+            let doneSize = self.doneButton.measure(CGSize(width: layout.size.width, height: headerHeight))
+            let doneFrame = CGRect(origin: CGPoint(x: layout.size.width - doneSize.width - 16.0, y: 18.0), size: doneSize)
+            transition.updateFrame(node: self.doneButton, frame: doneFrame)
+        }
+        
+        override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+            let result = super.hitTest(point, with: event)
+
+            if result === self.headerNode.view {
+                return self.view
+            }
+            
+            if result === self.headerNode.view {
+                return self.view
+            }
+            
+            if !self.bounds.contains(point) {
+                return nil
+            }
+            if point.y < self.headerNode.frame.minY {
+                return self.dimNode.view
+            }
+            return result
+        }
+        
+        @objc func dimTapGesture(_ recognizer: UITapGestureRecognizer) {
+            if case .ended = recognizer.state {
+                self.controller?.dismiss()
+            }
+        }
+        
+        private var panGestureArguments: CGFloat?
+        
+        @objc func panGesture(_ recognizer: UIPanGestureRecognizer) {
+            let contentOffset = self.listNode.visibleContentOffset()
+            switch recognizer.state {
+                case .began:
+                    self.panGestureArguments = 0.0
+                case .changed:
+                    var translation = recognizer.translation(in: self.contentNode.view).y
+                    if let currentPanOffset = self.panGestureArguments {
+                        
+
+                        if case let .known(value) = contentOffset, value <= 0.5 {
+                        } else {
+                            translation = currentPanOffset
+                        }
+
+                        self.panGestureArguments = translation
+                    }
+                    
+                    var bounds = self.contentNode.bounds
+                    bounds.origin.y = -translation
+                    bounds.origin.y = min(0.0, bounds.origin.y)
+                    self.contentNode.bounds = bounds
+                case .ended:
+                    let translation = recognizer.translation(in: self.contentNode.view)
+                    var velocity = recognizer.velocity(in: self.contentNode.view)
+
+                    if case let .known(value) = contentOffset, value > 0.0 {
+                        velocity = CGPoint()
+                    } else if case .unknown = contentOffset {
+                        velocity = CGPoint()
+                    }
+
+                    var bounds = self.contentNode.bounds
+                    bounds.origin.y = -translation.y
+                    bounds.origin.y = min(0.0, bounds.origin.y)
+
+                    self.panGestureArguments = nil
+                    if bounds.minY < -60 || (bounds.minY < 0.0 && velocity.y > 300.0) {
+                        self.controller?.dismiss()
+                    } else {
+                        var bounds = self.contentNode.bounds
+                        let previousBounds = bounds
+                        bounds.origin.y = 0.0
+                        self.contentNode.bounds = bounds
+                        self.contentNode.layer.animateBounds(from: previousBounds, to: self.contentNode.bounds, duration: 0.3, timingFunction: CAMediaTimingFunctionName.easeInEaseOut.rawValue)
+                    }
+                case .cancelled:
+                    self.panGestureArguments = nil
+
+                    let previousBounds = self.contentNode.bounds
+                    var bounds = self.contentNode.bounds
+                    bounds.origin.y = 0.0
+                    self.contentNode.bounds = bounds
+                    self.contentNode.layer.animateBounds(from: previousBounds, to: self.contentNode.bounds, duration: 0.3, timingFunction: CAMediaTimingFunctionName.easeInEaseOut.rawValue)
+                default:
+                    break
+            }
+        }
+        
+        private func updateFloatingHeaderOffset(offset: CGFloat, transition: ContainedViewLayoutTransition) {
+            guard let validLayout = self.validLayout else {
+                return
+            }
+            
+            self.floatingHeaderOffset = offset
+            
+            let layoutTopInset: CGFloat = max(validLayout.statusBarHeight ?? 0.0, validLayout.safeInsets.top)
+            
+            let controlsHeight: CGFloat = 44.0
+            
+            let listTopInset = layoutTopInset + controlsHeight
+            
+            let rawControlsOffset = offset + listTopInset - controlsHeight
+            let controlsOffset = max(layoutTopInset, rawControlsOffset)
+            let isOverscrolling = rawControlsOffset <= layoutTopInset
+            let controlsFrame = CGRect(origin: CGPoint(x: 0.0, y: controlsOffset), size: CGSize(width: validLayout.size.width, height: controlsHeight))
+            
+            let previousFrame = self.headerNode.frame
+            
+            if !controlsFrame.equalTo(previousFrame) {
+                self.headerNode.frame = controlsFrame
+                
+                let positionDelta = CGPoint(x: controlsFrame.minX - previousFrame.minX, y: controlsFrame.minY - previousFrame.minY)
+                
+                transition.animateOffsetAdditive(node: self.headerNode, offset: positionDelta.y)
+            }
+            
+//            transition.updateAlpha(node: self.headerNode.separatorNode, alpha: isOverscrolling ? 1.0 : 0.0)
+            
+            let backgroundFrame = CGRect(origin: CGPoint(x: 0.0, y: controlsFrame.maxY), size: CGSize(width: validLayout.size.width, height: validLayout.size.height))
+            
+            let previousBackgroundFrame = self.historyBackgroundNode.frame
+            
+            if !backgroundFrame.equalTo(previousBackgroundFrame) {
+                self.historyBackgroundNode.frame = backgroundFrame
+                self.historyBackgroundContentNode.frame = CGRect(origin: CGPoint(), size: backgroundFrame.size)
+                
+                let positionDelta = CGPoint(x: backgroundFrame.minX - previousBackgroundFrame.minX, y: backgroundFrame.minY - previousBackgroundFrame.minY)
+                
+                transition.animateOffsetAdditive(node: self.historyBackgroundNode, offset: positionDelta.y)
+            }
+        }
+    }
+}

submodules/InviteLinksUI/Sources/InviteLinksGridNode.swift

@@ -0,0 +1,504 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import SyncCore
+import TelegramPresentationData
+import ItemListUI
+import SolidRoundedButtonNode
+import RadialStatusNode
+
+private let itemSpacing: CGFloat = 10.0
+private let titleFont = Font.semibold(17.0)
+private let subtitleFont = Font.regular(12.0)
+
+private func generateBackgroundImage(colors: NSArray) -> UIImage? {
+    return generateImage(CGSize(width: 45, height: 45), contextGenerator: { size, context in
+        let bounds = CGRect(origin: CGPoint(), size: size)
+        context.clear(bounds)
+        
+        let path = UIBezierPath(roundedRect: CGRect(origin: CGPoint(), size: size), cornerRadius: 15)
+        context.addPath(path.cgPath)
+        context.clip()
+        
+        var locations: [CGFloat] = [0.0, 1.0]
+        let colorSpace = CGColorSpaceCreateDeviceRGB()
+        let gradient = CGGradient(colorsSpace: colorSpace, colors: colors, locations: &locations)!
+        
+        context.drawLinearGradient(gradient, start: CGPoint(), end: CGPoint(x: 0.0, y: bounds.size.height), options: CGGradientDrawingOptions())
+    })?.stretchableImage(withLeftCapWidth: 22, topCapHeight: 22)
+}
+
+func invitationAvailability(_ invite: ExportedInvitation) -> CGFloat {
+    let currentTime = Int32(CFAbsoluteTimeGetCurrent() + kCFAbsoluteTimeIntervalSince1970)
+    var availability: CGFloat = 1.0
+    if let expireDate = invite.expireDate {
+        let startDate = invite.startDate ?? invite.date
+        let fraction = CGFloat(expireDate - currentTime) / CGFloat(expireDate - startDate)
+        availability = min(fraction, availability)
+    }
+    if let usageLimit = invite.usageLimit, let count = invite.count {
+        let fraction = 1.0 - (CGFloat(count) / CGFloat(usageLimit))
+        availability = min(fraction, availability)
+    }
+    return availability
+}
+
+private class ItemNode: ASDisplayNode {
+    private let backgroundNode: ASImageNode
+    
+    private let iconNode: ASImageNode
+    private var timerNode: TimerNode?
+    
+    private let extractedContainerNode: ContextExtractedContentContainingNode
+    private let containerNode: ContextControllerSourceNode
+    private let buttonNode: HighlightTrackingButtonNode
+    private let buttonIconNode: ASImageNode
+    
+    private let titleNode: ImmediateTextNode
+    private let subtitleNode: ImmediateTextNode
+    
+    private var params: (size: CGSize, wide: Bool, invite: ExportedInvitation, presentationData: ItemListPresentationData)?
+    
+    var action: (() -> Void)?
+    var contextAction: ((ASDisplayNode) -> Void)?
+    
+    override init() {
+        self.backgroundNode = ASImageNode()
+        self.backgroundNode.displaysAsynchronously = false
+        self.backgroundNode.displayWithoutProcessing = true
+        
+        self.iconNode = ASImageNode()
+        self.iconNode.displaysAsynchronously = false
+        self.iconNode.displayWithoutProcessing = true
+        
+        self.buttonNode = HighlightTrackingButtonNode()
+        self.extractedContainerNode = ContextExtractedContentContainingNode()
+        self.containerNode = ContextControllerSourceNode()
+        self.containerNode.isGestureEnabled = false
+        self.buttonIconNode = ASImageNode()
+        self.buttonIconNode.displaysAsynchronously = false
+        self.buttonIconNode.displayWithoutProcessing = true
+        self.buttonIconNode.image = generateImage(CGSize(width: 26.0, height: 26.0), contextGenerator: { size, context in
+            context.clear(CGRect(origin: CGPoint(), size: size))
+            
+            context.setFillColor(UIColor.white.cgColor)
+            context.fillEllipse(in: CGRect(origin: CGPoint(), size: size))
+            
+            context.setBlendMode(.clear)
+            context.fillEllipse(in: CGRect(origin: CGPoint(x: 4.0, y: 11.0), size: CGSize(width: 4.0, height: 4.0)))
+            context.fillEllipse(in: CGRect(origin: CGPoint(x: 11.0, y: 11.0), size: CGSize(width: 4.0, height: 4.0)))
+            context.fillEllipse(in: CGRect(origin: CGPoint(x: 18.0, y: 11.0), size: CGSize(width: 4.0, height: 4.0)))
+        })
+        
+        self.titleNode = ImmediateTextNode()
+        self.titleNode.maximumNumberOfLines = 2
+        
+        self.subtitleNode = ImmediateTextNode()
+        self.subtitleNode.maximumNumberOfLines = 1
+        
+        super.init()
+        
+        self.addSubnode(self.backgroundNode)
+        self.addSubnode(self.iconNode)
+        
+        self.containerNode.addSubnode(self.extractedContainerNode)
+        self.extractedContainerNode.contentNode.addSubnode(self.buttonIconNode)
+        self.containerNode.targetNodeForActivationProgress = self.extractedContainerNode.contentNode
+        self.buttonNode.addSubnode(self.containerNode)
+        self.addSubnode(self.buttonNode)
+        
+        self.addSubnode(self.titleNode)
+        self.addSubnode(self.subtitleNode)
+        
+        self.buttonNode.addTarget(self, action: #selector(self.buttonPressed), forControlEvents: .touchUpInside)
+        self.buttonNode.highligthedChanged = { [weak self] highlighted in
+            if let strongSelf = self {
+                if highlighted {
+                    strongSelf.buttonIconNode.layer.removeAnimation(forKey: "opacity")
+                    strongSelf.buttonIconNode.alpha = 0.4
+                } else {
+                    strongSelf.buttonIconNode.alpha = 1.0
+                    strongSelf.buttonIconNode.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2)
+                }
+            }
+        }
+    }
+    
+    override func didLoad() {
+        self.view.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(self.tapGesture(_:))))
+    }
+    
+    @objc private func tapGesture(_ gestureRecognizer: UITapGestureRecognizer) {
+        self.action?()
+    }
+    
+    @objc private func buttonPressed() {
+        self.contextAction?(self.extractedContainerNode)
+    }
+    
+    func update(size: CGSize, wide: Bool, invite: ExportedInvitation, presentationData: ItemListPresentationData, transition: ContainedViewLayoutTransition) -> CGSize {
+        let updated = self.params?.size != size || self.params?.wide != wide || self.params?.invite != invite
+        self.params = (size, wide, invite, presentationData)
+        
+        let currentTime = Int32(CFAbsoluteTimeGetCurrent() + kCFAbsoluteTimeIntervalSince1970)
+        let availability = invitationAvailability(invite)
+
+        var isExpired = false
+        let secondaryTextColor: UIColor
+        if invite.isRevoked {
+            self.backgroundNode.image = generateBackgroundImage(colors: [UIColor(rgb: 0xd4d8db).cgColor, UIColor(rgb: 0xced2d5).cgColor])
+            secondaryTextColor = UIColor(rgb: 0xf8f9f9)
+        } else if invite.expireDate == nil && invite.usageLimit == nil {
+            self.backgroundNode.image = generateBackgroundImage(colors: [UIColor(rgb: 0x00b5f7).cgColor, UIColor(rgb: 0x00b2f6).cgColor])
+            secondaryTextColor = UIColor(rgb: 0xa7f4ff)
+        } else if availability >= 0.5 {
+            self.backgroundNode.image = generateBackgroundImage(colors: [UIColor(rgb: 0x4aca62).cgColor, UIColor(rgb: 0x43c85c).cgColor])
+            secondaryTextColor = UIColor(rgb: 0xc5ffe6)
+        } else if availability > 0.0 {
+            self.backgroundNode.image = generateBackgroundImage(colors: [UIColor(rgb: 0xf8a953).cgColor, UIColor(rgb: 0xf7a64e).cgColor])
+            secondaryTextColor = UIColor(rgb: 0xfeffd7)
+        } else {
+            self.backgroundNode.image = generateBackgroundImage(colors: [UIColor(rgb: 0xf2656a).cgColor, UIColor(rgb: 0xf25f65).cgColor])
+            secondaryTextColor = UIColor(rgb: 0xffd3de)
+            isExpired = true
+        }
+        
+        let itemWidth = wide ? size.width : floor((size.width - itemSpacing) / 2.0)
+
+        var inviteLink = invite.link.replacingOccurrences(of: "https://", with: "")
+        if !wide {
+            inviteLink = inviteLink.replacingOccurrences(of: "joinchat/", with: "joinchat/\n")
+            inviteLink = inviteLink.replacingOccurrences(of: "join/", with: "join/\n")
+        }
+        let title: NSMutableAttributedString = NSMutableAttributedString(string: inviteLink, font: titleFont, textColor: UIColor.white)
+        if inviteLink.hasPrefix("t.me/joinchat/") {
+            title.addAttribute(NSAttributedString.Key.foregroundColor, value: secondaryTextColor, range: NSMakeRange(0, "t.me/joinchat/".count))
+        } else if inviteLink.hasPrefix("t.me/join/") {
+            title.addAttribute(NSAttributedString.Key.foregroundColor, value: secondaryTextColor, range: NSMakeRange(0, "t.me/join/".count))
+        }
+        self.titleNode.attributedText = title
+        
+        var subtitleText: String = ""
+        if let count = invite.count {
+            subtitleText = presentationData.strings.InviteLink_PeopleJoinedShort(count)
+        } else {
+            subtitleText = isExpired || invite.isRevoked ? presentationData.strings.InviteLink_PeopleJoinedShortNoneExpired : presentationData.strings.InviteLink_PeopleJoinedShortNone
+        }
+        if invite.isRevoked {
+            if !subtitleText.isEmpty {
+                subtitleText += " • "
+            }
+            subtitleText += presentationData.strings.InviteLink_Revoked
+            self.iconNode.image = generateTintedImage(image: UIImage(bundleImageName: "Chat/Links/Expired"), color: .white)
+            self.timerNode?.removeFromSupernode()
+            self.timerNode = nil
+        } else if let expireDate = invite.expireDate, currentTime > expireDate {
+            if !subtitleText.isEmpty {
+                subtitleText += " • "
+            }
+            subtitleText += presentationData.strings.InviteLink_Expired
+            self.iconNode.image = generateTintedImage(image: UIImage(bundleImageName: "Chat/Links/Expired"), color: .white)
+            self.timerNode?.removeFromSupernode()
+            self.timerNode = nil
+        } else if let expireDate = invite.expireDate {
+            self.iconNode.image = generateTintedImage(image: UIImage(bundleImageName: "Chat/Links/Flame"), color: .white)
+            let timerNode: TimerNode
+            if let current = self.timerNode {
+                timerNode = current
+            } else {
+                timerNode = TimerNode()
+                self.timerNode = timerNode
+                self.addSubnode(timerNode)
+            }
+            timerNode.update(color: UIColor.white, creationTimestamp: invite.date, deadlineTimestamp: expireDate)
+        } else {
+            self.iconNode.image = generateTintedImage(image: UIImage(bundleImageName: "Chat/Links/Link"), color: .white)
+            self.timerNode?.removeFromSupernode()
+            self.timerNode = nil
+        }
+        
+        self.iconNode.frame = CGRect(x: 10.0, y: 10.0, width: 30.0, height: 30.0)
+        self.timerNode?.frame = CGRect(x: 8.0, y: 8.0, width: 34.0, height: 34.0)
+
+        let subtitle: NSMutableAttributedString = NSMutableAttributedString(string: subtitleText, font: subtitleFont, textColor: secondaryTextColor)
+        self.subtitleNode.attributedText = subtitle
+        
+        let titleSize = self.titleNode.updateLayout(CGSize(width: itemWidth - 24.0, height: 100.0))
+        let subtitleSize = self.subtitleNode.updateLayout(CGSize(width: itemWidth - 24.0, height: 100.0))
+        
+        self.titleNode.frame = CGRect(origin: CGPoint(x: 12.0, y: 52.0), size: titleSize)
+        self.subtitleNode.frame = CGRect(origin: CGPoint(x: 12.0, y: 52.0 + titleSize.height + 3.0), size: subtitleSize)
+        
+        let itemSize = CGSize(width: itemWidth, height: wide ? 102.0 : 122.0)
+        
+        let backgroundFrame = CGRect(origin: CGPoint(), size: itemSize)
+        transition.updateFrame(node: self.backgroundNode, frame: backgroundFrame)
+        
+        let buttonSize = CGSize(width: 26.0, height: 26.0)
+        let buttonFrame = CGRect(origin: CGPoint(x: itemSize.width - buttonSize.width - 12.0, y: 12.0), size: buttonSize)
+        transition.updateFrame(node: self.buttonNode, frame: buttonFrame)
+        
+        self.extractedContainerNode.frame = CGRect(origin: CGPoint(), size: buttonSize)
+        self.extractedContainerNode.contentRect = CGRect(origin: CGPoint(), size: buttonSize)
+        self.buttonIconNode.frame = CGRect(origin: CGPoint(), size: buttonSize)
+        
+        return itemSize
+    }
+}
+
+class InviteLinksGridNode: ASDisplayNode {
+    private var items: [ExportedInvitation] = []
+    private var itemNodes: [String: ItemNode] = [:]
+    
+    var action: ((ExportedInvitation) -> Void)?
+    var contextAction: ((ASDisplayNode, ExportedInvitation) -> Void)?
+    
+    override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+        let result = super.hitTest(point, with: event)
+        return result
+    }
+    
+    func update(size: CGSize, safeInset: CGFloat, items: [ExportedInvitation], presentationData: ItemListPresentationData, transition: ContainedViewLayoutTransition) -> CGSize {
+        self.items = items
+        
+        var contentSize: CGSize = size
+        var contentHeight: CGFloat = 0.0
+        
+        let sideInset: CGFloat = 16.0 + safeInset
+        
+        var validIds = Set<String>()
+        
+        for i in 0 ..< self.items.count {
+            let invite = self.items[i]
+            validIds.insert(invite.link)
+            var itemNode: ItemNode?
+            var wasAdded = false
+            if let current = self.itemNodes[invite.link] {
+                itemNode = current
+            } else {
+                wasAdded = true
+                let addedItemNode = ItemNode()
+                itemNode = addedItemNode
+                self.itemNodes[invite.link] = addedItemNode
+                self.addSubnode(addedItemNode)
+            }
+            if let itemNode = itemNode {
+                let col = CGFloat(i % 2)
+                let row = floor(CGFloat(i) / 2.0)
+                let wide = (i == self.items.count - 1 && (self.items.count % 2) != 0)
+                let itemSize = itemNode.update(size: CGSize(width: size.width - sideInset * 2.0, height: size.height), wide: wide, invite: invite, presentationData: presentationData, transition: transition)
+                var itemFrame = CGRect(origin: CGPoint(x: sideInset, y: 4.0 + row * (122.0 + itemSpacing)), size: itemSize)
+                if !wide && col > 0 {
+                    itemFrame.origin.x += itemSpacing + itemSize.width
+                }
+                
+                contentHeight = max(contentHeight, itemFrame.maxY + itemSpacing)
+                
+                if wasAdded {
+                    itemNode.frame = itemFrame
+                } else {
+                    transition.updateFrame(node: itemNode, frame: itemFrame)
+                }
+                itemNode.action = { [weak self] in
+                    self?.action?(invite)
+                }
+                itemNode.contextAction = { [weak self] node in
+                    self?.contextAction?(node, invite)
+                }
+            }
+        }
+
+        var removeIds: [String] = []
+        for (id, _) in self.itemNodes {
+            if !validIds.contains(id) {
+                removeIds.append(id)
+            }
+        }
+        for id in removeIds {
+            if let itemNode = self.itemNodes.removeValue(forKey: id) {
+                itemNode.removeFromSupernode()
+            }
+        }
+        
+        contentSize.height = contentHeight
+        return contentSize
+    }
+}
+
+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 {
+    private struct Params: Equatable {
+        var color: UIColor
+        var creationTimestamp: Int32
+        var deadlineTimestamp: Int32
+    }
+    
+    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, creationTimestamp: Int32, deadlineTimestamp: Int32) {
+        let params = Params(
+            color: color,
+            creationTimestamp: creationTimestamp,
+            deadlineTimestamp: deadlineTimestamp
+        )
+        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(params.deadlineTimestamp - currentTimestamp) / CGFloat(params.deadlineTimestamp - params.creationTimestamp)
+        fraction = 1.0 - max(0.0, min(0.94, fraction))
+      
+        let image: UIImage?
+        
+        let diameter: CGFloat = 26.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 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()
+            
+            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/ItemListDatePickerItem.swift

@@ -0,0 +1,241 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import SyncCore
+import TelegramPresentationData
+import ItemListUI
+
+public class ItemListDatePickerItem: ListViewItem, ItemListItem {
+    let presentationData: ItemListPresentationData
+    let date: Int32?
+    public let sectionId: ItemListSectionId
+    let style: ItemListStyle
+    let updated: ((Int32) -> Void)?
+    public let tag: ItemListItemTag?
+    
+    public init(
+        presentationData: ItemListPresentationData,
+        date: Int32?,
+        sectionId: ItemListSectionId,
+        style: ItemListStyle,
+        updated: ((Int32) -> Void)?,
+        tag: ItemListItemTag? = nil
+    ) {
+        self.presentationData = presentationData
+        self.date = date
+        self.sectionId = sectionId
+        self.style = style
+        self.updated = updated
+        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 = ItemListDatePickerItemNode()
+            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? ItemListDatePickerItemNode {
+                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 ItemListDatePickerItemNode: ListViewItemNode, ItemListItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let datePicker: UIDatePicker
+    
+    private var item: ItemListDatePickerItem?
+    
+    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.datePicker = UIDatePicker()
+        self.datePicker.minimumDate = Date()
+        self.datePicker.datePickerMode = .dateAndTime
+        if #available(iOS 14.0, *) {
+            self.datePicker.preferredDatePickerStyle = .inline
+        }
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.datePicker.addTarget(self, action: #selector(self.datePickerUpdated), for: .valueChanged)
+    }
+    
+    public override func didLoad() {
+        super.didLoad()
+        
+        self.view.addSubview(self.datePicker)
+    }
+    
+    @objc private func datePickerUpdated() {
+        self.item?.updated?(Int32(self.datePicker.date.timeIntervalSince1970))
+    }
+    
+    public func asyncLayout() -> (_ item: ItemListDatePickerItem, _ params: ListViewItemLayoutParams, _ insets: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let currentItem = self.item
+        
+        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 height: CGFloat = 360.0
+            
+            switch item.style {
+            case .plain:
+                itemBackgroundColor = item.presentationData.theme.list.plainBackgroundColor
+                itemSeparatorColor = item.presentationData.theme.list.itemPlainSeparatorColor
+                contentSize = CGSize(width: params.width, height: height)
+                insets = itemListNeighborsPlainInsets(neighbors)
+            case .blocks:
+                itemBackgroundColor = item.presentationData.theme.list.itemBlocksBackgroundColor
+                itemSeparatorColor = item.presentationData.theme.list.itemBlocksSeparatorColor
+                contentSize = CGSize(width: params.width, height: height)
+                insets = itemListNeighborsGroupedInsets(neighbors)
+            }
+            
+            return (ListViewItemNodeLayout(contentSize: contentSize, insets: insets), { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+
+                    if let _ = updatedTheme {
+                        strongSelf.topStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.bottomStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.backgroundNode.backgroundColor = itemBackgroundColor
+                    }
+                
+                    strongSelf.datePicker.date = item.date.flatMap { Date(timeIntervalSince1970: TimeInterval($0)) } ?? Date()
+                    strongSelf.datePicker.frame = CGRect(origin: CGPoint(x: 16.0, y: 3.0), size: CGSize(width: contentSize.width - 32.0, height: contentSize.height))
+                    
+                    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
+                            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))
+                    }
+                }
+            })
+        }
+    }
+    
+    override public func animateInsertion(_ currentTimestamp: Double, duration: Double, short: Bool) {
+        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)
+    }
+}
+

submodules/InviteLinksUI/Sources/ItemListInviteLinkDateLimitItem.swift

@@ -0,0 +1,409 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramCore
+import SyncCore
+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 func generateKnobImage() -> UIImage? {
+    return generateImage(CGSize(width: 40.0, height: 40.0), rotatedContext: { size, context in
+        context.clear(CGRect(origin: CGPoint(), size: size))
+        context.setShadow(offset: CGSize(width: 0.0, height: -2.0), blur: 3.5, color: UIColor(white: 0.0, alpha: 0.35).cgColor)
+        context.setFillColor(UIColor.white.cgColor)
+        context.fillEllipse(in: CGRect(origin: CGPoint(x: 6.0, y: 6.0), size: CGSize(width: 28.0, height: 28.0)))
+    })
+}
+
+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 = 1.0
+        sliderView.lineSize = 2.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.disclosureArrowColor
+            sliderView.startColor = item.theme.list.disclosureArrowColor
+            sliderView.trackColor = item.theme.list.itemAccentColor
+            sliderView.knobImage = generateKnobImage()
+            
+            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)
+            
+            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
+                    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.disclosureArrowColor
+                            sliderView.trackColor = item.theme.list.itemAccentColor
+                            sliderView.knobImage = generateKnobImage()
+                        }
+                        
+                        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, short: Bool) {
+        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/ItemListInviteLinkGridItem.swift

@@ -0,0 +1,253 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import SyncCore
+import TelegramPresentationData
+import ItemListUI
+
+public class ItemListInviteLinkGridItem: ListViewItem, ItemListItem {
+    let presentationData: ItemListPresentationData
+    let invites: [ExportedInvitation]?
+    public let sectionId: ItemListSectionId
+    let style: ItemListStyle
+    let tapAction: ((ExportedInvitation) -> Void)?
+    let contextAction: ((ExportedInvitation, ASDisplayNode) -> Void)?
+    public let tag: ItemListItemTag?
+    
+    public init(
+        presentationData: ItemListPresentationData,
+        invites: [ExportedInvitation]?,
+        sectionId: ItemListSectionId,
+        style: ItemListStyle,
+        tapAction: ((ExportedInvitation) -> Void)?,
+        contextAction: ((ExportedInvitation, ASDisplayNode) -> Void)?,
+        tag: ItemListItemTag? = nil
+    ) {
+        self.presentationData = presentationData
+        self.invites = invites
+        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 {
+            let node = ItemListInviteLinkGridItemNode()
+            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? ItemListInviteLinkGridItemNode {
+                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 func selected(listView: ListView){
+    }
+}
+
+public class ItemListInviteLinkGridItemNode: ListViewItemNode, ItemListItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let gridNode: InviteLinksGridNode
+    
+    private var item: ItemListInviteLinkGridItem?
+    
+    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.gridNode = InviteLinksGridNode()
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.gridNode)
+    }
+    
+    public func asyncLayout() -> (_ item: ItemListInviteLinkGridItem, _ params: ListViewItemLayoutParams, _ insets: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let currentItem = self.item
+        
+        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
+            
+            var height: CGFloat
+            let count = item.invites?.count ?? 0
+            if count > 0 {
+                if count % 2 == 0 {
+                    height = 4.0 + 122.0 + 6.0
+                } else {
+                    height = 4.0 + 102.0 + 6.0
+                }
+            } else {
+                height = 0.001
+            }
+            
+            switch item.style {
+            case .plain:
+                itemBackgroundColor = item.presentationData.theme.list.plainBackgroundColor
+                itemSeparatorColor = item.presentationData.theme.list.itemPlainSeparatorColor
+                insets = itemListNeighborsPlainInsets(neighbors)
+            case .blocks:
+                itemBackgroundColor = item.presentationData.theme.list.itemBlocksBackgroundColor
+                itemSeparatorColor = item.presentationData.theme.list.itemBlocksSeparatorColor
+                insets = itemListNeighborsGroupedInsets(neighbors)
+            }
+            if case .sameSection(false) = neighbors.bottom {
+            } else {
+                height += 6.0
+            }
+            contentSize = CGSize(width: params.width, height: height)
+            
+            return (ListViewItemNodeLayout(contentSize: contentSize, insets: insets), { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+
+                    if let _ = updatedTheme {
+                        strongSelf.topStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.bottomStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.backgroundNode.backgroundColor = itemBackgroundColor
+                    }
+                    
+                    let gridSize = strongSelf.gridNode.update(size: contentSize, safeInset: params.leftInset,  items: item.invites ?? [], presentationData: item.presentationData, transition: .immediate)
+                    strongSelf.gridNode.frame = CGRect(origin: CGPoint(), size: gridSize)
+                    strongSelf.gridNode.action = { invite in
+                        item.tapAction?(invite)
+                    }
+                    strongSelf.gridNode.contextAction = { node, invite in
+                        item.contextAction?(invite, node)
+                    }
+                    
+                    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 = true
+                            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))
+                    }
+                }
+            })
+        }
+    }
+    
+    override public func animateInsertion(_ currentTimestamp: Double, duration: Double, short: Bool) {
+        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)
+    }
+}
+

submodules/InviteLinksUI/Sources/ItemListInviteLinkUsageLimitItem.swift

@@ -0,0 +1,415 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramCore
+import SyncCore
+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 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 nil
+        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 value: InviteLinkUsageLimit
+    let enabled: Bool
+    let sectionId: ItemListSectionId
+    let updated: (InviteLinkUsageLimit) -> Void
+    
+    init(theme: PresentationTheme, strings: PresentationStrings, value: InviteLinkUsageLimit, enabled: Bool, sectionId: ItemListSectionId, updated: @escaping (InviteLinkUsageLimit) -> 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 = 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 func generateKnobImage() -> UIImage? {
+    return generateImage(CGSize(width: 40.0, height: 40.0), rotatedContext: { size, context in
+        context.clear(CGRect(origin: CGPoint(), size: size))
+        context.setShadow(offset: CGSize(width: 0.0, height: -2.0), blur: 3.5, color: UIColor(white: 0.0, alpha: 0.35).cgColor)
+        context.setFillColor(UIColor.white.cgColor)
+        context.fillEllipse(in: CGRect(origin: CGPoint(x: 6.0, y: 6.0), size: CGSize(width: 28.0, height: 28.0)))
+    })
+}
+
+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 = 1.0
+        sliderView.lineSize = 2.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.disclosureArrowColor
+            sliderView.startColor = item.theme.list.disclosureArrowColor
+            sliderView.trackColor = item.theme.list.itemAccentColor
+            sliderView.knobImage = generateKnobImage()
+            
+            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 = "\(value)"
+            } 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)
+            
+            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
+                    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.disclosureArrowColor
+                            sliderView.trackColor = item.theme.list.itemAccentColor
+                            sliderView.knobImage = generateKnobImage()
+                        }
+                        
+                        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, short: Bool) {
+        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/ItemListPermanentInviteLinkItem.swift

@@ -0,0 +1,451 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import Postbox
+import SyncCore
+import AccountContext
+import TelegramPresentationData
+import ItemListUI
+import SolidRoundedButtonNode
+import AnimatedAvatarSetNode
+
+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 invite: ExportedInvitation?
+    let peers: [Peer]
+    let buttonColor: UIColor?
+    public let sectionId: ItemListSectionId
+    let style: ItemListStyle
+    let shareAction: (() -> Void)?
+    let contextAction: ((ASDisplayNode) -> Void)?
+    let viewAction: (() -> Void)?
+    public let tag: ItemListItemTag?
+    
+    public init(
+        context: AccountContext,
+        presentationData: ItemListPresentationData,
+        invite: ExportedInvitation?,
+        peers: [Peer],
+        buttonColor: UIColor?,
+        sectionId: ItemListSectionId,
+        style: ItemListStyle,
+        shareAction: (() -> Void)?,
+        contextAction: ((ASDisplayNode) -> Void)?,
+        viewAction: (() -> Void)?,
+        tag: ItemListItemTag? = nil
+    ) {
+        self.context = context
+        self.presentationData = presentationData
+        self.invite = invite
+        self.peers = peers
+        self.buttonColor = buttonColor
+        self.sectionId = sectionId
+        self.style = style
+        self.shareAction = shareAction
+        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 = 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 extractedContainerNode: ContextExtractedContentContainingNode
+    private let containerNode: ContextControllerSourceNode
+    private let addressButtonNode: HighlightTrackingButtonNode
+    private let addressButtonIconNode: ASImageNode
+    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 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.addressButtonNode = HighlightTrackingButtonNode()
+        self.extractedContainerNode = ContextExtractedContentContainingNode()
+        self.containerNode = ContextControllerSourceNode()
+        self.containerNode.isGestureEnabled = false
+        self.addressButtonIconNode = ASImageNode()
+        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.avatarsNode)
+        self.addSubnode(self.invitedPeersNode)
+        self.addSubnode(self.avatarsButtonNode)
+        
+        self.containerNode.addSubnode(self.extractedContainerNode)
+        self.extractedContainerNode.contentNode.addSubnode(self.addressButtonIconNode)
+        self.containerNode.targetNodeForActivationProgress = self.extractedContainerNode.contentNode
+        self.addressButtonNode.addSubnode(self.containerNode)
+        self.addSubnode(self.addressButtonNode)
+        
+        self.addSubnode(self.activateArea)
+        
+        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 addressButtonPressed() {
+        if let item = self.item {
+            item.contextAction?(self.extractedContainerNode)
+        }
+    }
+    
+    @objc private func avatarsButtonPressed() {
+        if let item = self.item {
+            item.viewAction?()
+        }
+    }
+    
+    public func asyncLayout() -> (_ item: ItemListPermanentInviteLinkItem, _ 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.itemPrimaryTextColor
+            
+            let titleFont = Font.regular(item.presentationData.fontSize.itemListBaseFontSize)
+            
+            let (addressLayout, addressApply) = makeAddressLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.invite.flatMap({ $0.link.replacingOccurrences(of: "https://", with: "") }) ?? "", font: titleFont, textColor: titleColor), 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 subtitle: String
+            let subtitleColor: UIColor
+            if let count = item.invite?.count {
+                if count > 0 {
+                    subtitle = item.presentationData.strings.InviteLink_PeopleJoined(count)
+                    subtitleColor = item.presentationData.theme.list.itemAccentColor
+                } else {
+                    subtitle = item.presentationData.strings.InviteLink_PeopleJoinedNone
+                    subtitleColor = item.presentationData.theme.list.itemSecondaryTextColor
+                }
+            } 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 = 50.0
+            
+            var height = verticalInset * 2.0 + fieldHeight + fieldSpacing + buttonHeight + 54.0
+            
+            switch item.style {
+            case .plain:
+                height -= 57.0
+                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)
+            }
+            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: 18.0, color: item.presentationData.theme.list.freePlainInputField.backgroundColor)
+                        strongSelf.addressButtonIconNode.image = actionButtonImage(color: item.presentationData.theme.list.freePlainInputField.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
+                            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 fieldFrame = CGRect(origin: CGPoint(x: leftInset, y: verticalInset), size: CGSize(width: params.width - leftInset - rightInset, height: fieldHeight))
+                    strongSelf.fieldNode.frame = fieldFrame
+                    
+                    strongSelf.addressNode.frame = CGRect(origin: CGPoint(x: fieldFrame.minX + floorToScreenPixels((fieldFrame.width - addressLayout.size.width) / 2.0), y: fieldFrame.minY + floorToScreenPixels((fieldFrame.height - addressLayout.size.height) / 2.0) + 1.0), size: addressLayout.size)
+                    
+                    strongSelf.addressButtonNode.frame = CGRect(origin: CGPoint(x: params.width - rightInset - 38.0, y: verticalInset + 14.0), size: CGSize(width: 24.0, height: 24.0))
+                    strongSelf.extractedContainerNode.frame = strongSelf.addressButtonNode.bounds
+                    strongSelf.extractedContainerNode.contentRect = strongSelf.addressButtonNode.bounds
+                    strongSelf.addressButtonIconNode.frame = strongSelf.addressButtonNode.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, height: 50.0, cornerRadius: 10.0)
+                        shareButtonNode.title = item.presentationData.strings.InviteLink_Share
+                        shareButtonNode.pressed = {
+                            item.shareAction?()
+                        }
+                        strongSelf.addSubnode(shareButtonNode)
+                        strongSelf.shareButtonNode = shareButtonNode
+                    }
+                    
+                    let buttonWidth = contentSize.width - leftInset - rightInset
+                    let _ = shareButtonNode.updateLayout(width: buttonWidth, transition: .immediate)
+                    shareButtonNode.frame = CGRect(x: leftInset, y: verticalInset + fieldHeight + fieldSpacing, width: buttonWidth, 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
+                }
+            })
+        }
+    }
+    
+    override public func animateInsertion(_ currentTimestamp: Double, duration: Double, short: Bool) {
+        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)
+    }
+}