GLEGram 12.5 — Initial public release

Based on Swiftgram 12.5 (Telegram iOS 12.5).
All GLEGram features ported and organized in GLEGram/ folder.

Features: Ghost Mode, Saved Deleted Messages, Content Protection Bypass,
Font Replacement, Fake Profile, Chat Export, Plugin System, and more.

See CHANGELOG_12.5.md for full details.

submodules/SettingsUI/Sources/Search/SettingsSearchItem.swift

@@ -0,0 +1,724 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import Postbox
+import TelegramCore
+import SwiftSignalKit
+import TelegramPresentationData
+import MergeLists
+import ItemListUI
+import PresentationDataUtils
+import AccountContext
+import SearchBarNode
+import SearchUI
+import ChatListSearchItemHeader
+import EdgeEffect
+import ComponentFlow
+import ComponentDisplayAdapters
+
+extension SettingsSearchableItemIcon {
+    func image() -> UIImage? {
+        switch self {
+            case .profile:
+                return PresentationResourcesSettings.editProfile
+            case .proxy:
+                return PresentationResourcesSettings.proxy
+            case .savedMessages:
+                return PresentationResourcesSettings.savedMessages
+            case .calls:
+                return PresentationResourcesSettings.recentCalls
+            case .stickers:
+                return PresentationResourcesSettings.stickers
+            case .notifications:
+                return PresentationResourcesSettings.notifications
+            case .privacy:
+                return PresentationResourcesSettings.security
+            case .data:
+                return PresentationResourcesSettings.dataAndStorage
+            case .appearance:
+                return PresentationResourcesSettings.appearance
+            case .language:
+                return PresentationResourcesSettings.language
+            case .watch:
+                return PresentationResourcesSettings.watch
+            case .passport:
+                return PresentationResourcesSettings.passport
+            case .support:
+                return PresentationResourcesSettings.support
+            case .faq:
+                return PresentationResourcesSettings.faq
+            case .tips:
+                return PresentationResourcesSettings.tips
+            case .chatFolders:
+                return PresentationResourcesSettings.chatFolders
+            case .deleteAccount:
+                return PresentationResourcesSettings.deleteAccount
+            case .devices:
+                return PresentationResourcesSettings.devices
+            case .premium:
+                return PresentationResourcesSettings.premium
+            case .business:
+                return PresentationResourcesSettings.business
+            case .stars:
+                return PresentationResourcesSettings.stars
+            case .ton:
+                return PresentationResourcesSettings.ton
+            case .stories:
+                return PresentationResourcesSettings.stories
+            case .myProfile:
+                return PresentationResourcesSettings.myProfile
+            case .gift:
+                return PresentationResourcesSettings.premiumGift
+            case .powerSaving:
+                return PresentationResourcesSettings.powerSaving
+        }
+    }
+}
+
+final class SettingsSearchInteraction {
+    let openItem: (SettingsSearchableItem) -> Void
+    let openItemContextMenu: (SettingsSearchableItem, ContextExtractedContentContainingNode, CGRect, UIGestureRecognizer?) -> Void
+    let deleteRecentItem: (AnyHashable) -> Void
+    
+    init(
+        openItem: @escaping (SettingsSearchableItem) -> Void,
+        openItemContextMenu: @escaping (SettingsSearchableItem, ContextExtractedContentContainingNode, CGRect, UIGestureRecognizer?) -> Void,
+        deleteRecentItem: @escaping (AnyHashable) -> Void
+    ) {
+        self.openItem = openItem
+        self.openItemContextMenu = openItemContextMenu
+        self.deleteRecentItem = deleteRecentItem
+    }
+}
+
+private enum SettingsSearchEntryStableId: Hashable {
+    case result(AnyHashable)
+}
+
+private enum SettingsSearchEntry: Comparable, Identifiable {
+    case result(index: Int, item: SettingsSearchableItem, icon: UIImage?)
+    
+    var stableId: SettingsSearchEntryStableId {
+        switch self {
+            case let .result(_, item, _):
+                return .result(item.id)
+        }
+    }
+    
+    private func index() -> Int {
+        switch self {
+            case let .result(index, _, _):
+                return index
+        }
+    }
+    
+    static func <(lhs: SettingsSearchEntry, rhs: SettingsSearchEntry) -> Bool {
+        return lhs.index() < rhs.index()
+    }
+    
+    static func == (lhs: SettingsSearchEntry, rhs: SettingsSearchEntry) -> Bool {
+        if case let .result(lhsIndex, lhsItem, _) = lhs {
+            if case let .result(rhsIndex, rhsItem, _) = rhs, lhsIndex == rhsIndex, lhsItem.id == rhsItem.id {
+                return true
+            }
+        }
+        return false
+    }
+    
+    func item(theme: PresentationTheme, strings: PresentationStrings, interaction: SettingsSearchInteraction)  -> ListViewItem {
+        switch self {
+            case let .result(_, item, icon):
+                return SettingsSearchResultItem(theme: theme, strings: strings, item: item, icon: icon, interaction: interaction, sectionId: 0)
+        }
+    }
+}
+
+private struct SettingsSearchContainerTransition {
+    let deletions: [ListViewDeleteItem]
+    let insertions: [ListViewInsertItem]
+    let updates: [ListViewUpdateItem]
+    let isSearching: Bool
+}
+
+private func preparedSettingsSearchContainerTransition(theme: PresentationTheme, strings: PresentationStrings, from fromEntries: [SettingsSearchEntry], to toEntries: [SettingsSearchEntry], interaction: SettingsSearchInteraction, isSearching: Bool, forceUpdate: Bool) -> SettingsSearchContainerTransition {
+    let (deleteIndices, indicesAndItems, updateIndices) = mergeListsStableWithUpdates(leftList: fromEntries, rightList: toEntries, allUpdated: forceUpdate)
+    
+    let deletions = deleteIndices.map { ListViewDeleteItem(index: $0, directionHint: nil) }
+    let insertions = indicesAndItems.map { ListViewInsertItem(index: $0.0, previousIndex: $0.2, item: $0.1.item(theme: theme, strings: strings, interaction: interaction), directionHint: nil) }
+    let updates = updateIndices.map { ListViewUpdateItem(index: $0.0, previousIndex: $0.2, item: $0.1.item(theme: theme, strings: strings, interaction: interaction), directionHint: nil) }
+    
+    return SettingsSearchContainerTransition(deletions: deletions, insertions: insertions, updates: updates, isSearching: isSearching)
+}
+
+private enum SettingsSearchRecentEntryStableId: Hashable {
+    case recent(AnyHashable)
+}
+
+private enum SettingsSearchRecentEntry: Comparable, Identifiable {
+    case recent(Int, SettingsSearchableItem, ChatListSearchItemHeader)
+    case faq(Int, SettingsSearchableItem, ChatListSearchItemHeader)
+    
+    var stableId: SettingsSearchRecentEntryStableId {
+        switch self {
+            case let .recent(_, item, _), let .faq(_, item, _):
+                return .recent(item.id)
+        }
+    }
+    
+    var header: ChatListSearchItemHeader {
+        switch self {
+            case let .recent(_, _, header), let .faq(_, _, header):
+                return header
+        }
+    }
+    
+    static func ==(lhs: SettingsSearchRecentEntry, rhs: SettingsSearchRecentEntry) -> Bool {
+        switch lhs {
+            case let .recent(lhsIndex, lhsItem, lhsHeader):
+                if case let .recent(rhsIndex, rhsItem, rhsHeader) = rhs, lhsIndex == rhsIndex, lhsItem.id == rhsItem.id, lhsHeader.id == rhsHeader.id {
+                    return true
+                } else {
+                    return false
+                }
+            case let .faq(lhsIndex, lhsItem, lhsHeader):
+                if case let .faq(rhsIndex, rhsItem, rhsHeader) = rhs, lhsIndex == rhsIndex, lhsItem.id == rhsItem.id, lhsHeader.id == rhsHeader.id {
+                    return true
+                } else {
+                    return false
+                }
+        }
+    }
+    
+    static func <(lhs: SettingsSearchRecentEntry, rhs: SettingsSearchRecentEntry) -> Bool {
+        switch lhs {
+            case let .recent(lhsIndex, _, _):
+                switch rhs {
+                    case let .recent(rhsIndex, _, _):
+                        return lhsIndex <= rhsIndex
+                    case .faq:
+                        return false
+                }
+            case let .faq(lhsIndex, _, _):
+                switch rhs {
+                    case .recent:
+                        return true
+                    case let .faq(rhsIndex, _, _):
+                        return lhsIndex <= rhsIndex
+                }
+        }
+    }
+    
+    func item(account: Account, theme: PresentationTheme, strings: PresentationStrings, interaction: SettingsSearchInteraction) -> ListViewItem {
+        switch self {
+            case let .recent(_, item, header):
+                var title = item.title
+                if title.isEmpty, let id = item.id.base as? String {
+                    title = id
+                }
+                return SettingsSearchRecentItem(account: account, theme: theme, strings: strings, title: title, breadcrumbs: item.breadcrumbs, isFaq: false, action: {
+                    interaction.openItem(item)
+                }, deleted: {
+                    interaction.deleteRecentItem(item.id)
+                }, header: header)
+            case let .faq(_, item, header):
+                return SettingsSearchRecentItem(account: account, theme: theme, strings: strings, title: item.title, breadcrumbs: item.breadcrumbs, isFaq: true, action: {
+                    interaction.openItem(item)
+                }, deleted: {
+                    interaction.deleteRecentItem(item.id)
+                }, header: header)
+        }
+    }
+}
+
+private struct SettingsSearchContainerRecentTransition {
+    let deletions: [ListViewDeleteItem]
+    let insertions: [ListViewInsertItem]
+    let updates: [ListViewUpdateItem]
+    let isEmpty: Bool
+}
+
+private func preparedSettingsSearchContainerRecentTransition(from fromEntries: [SettingsSearchRecentEntry], to toEntries: [SettingsSearchRecentEntry], account: Account, theme: PresentationTheme, strings: PresentationStrings, interaction: SettingsSearchInteraction) -> SettingsSearchContainerRecentTransition {
+    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, theme: theme, strings: strings, interaction: interaction), directionHint: nil) }
+    let updates = updateIndices.map { ListViewUpdateItem(index: $0.0, previousIndex: $0.2, item: $0.1.item(account: account, theme: theme, strings: strings, interaction: interaction), directionHint: nil) }
+    
+    return SettingsSearchContainerRecentTransition(deletions: deletions, insertions: insertions, updates: updates, isEmpty: toEntries.isEmpty)
+}
+
+
+public final class SettingsSearchContainerNode: SearchDisplayControllerContentNode {
+    private let listNode: ListView
+    private let recentListNode: ListView
+    
+    private let edgeEffectView: EdgeEffectView
+    
+    private var enqueuedTransitions: [SettingsSearchContainerTransition] = []
+    private var enqueuedRecentTransitions: [(SettingsSearchContainerRecentTransition, Bool)] = []
+    private var hasValidLayout = false
+    
+    private let searchQuery = Promise<String?>()
+    private let searchDisposable = MetaDisposable()
+    
+    private var recentDisposable: Disposable?
+    
+    private var presentationData: PresentationData
+    private var presentationDataDisposable: Disposable?
+    private let presentationDataPromise: Promise<PresentationData>
+    
+    public init(
+        context: AccountContext,
+        openResult: @escaping (SettingsSearchableItem) -> Void,
+        openContextMenu: @escaping (SettingsSearchableItem, ContextExtractedContentContainingNode, CGRect, UIGestureRecognizer?) -> Void,
+        resolvedFaqUrl: Signal<ResolvedUrl?, NoError>,
+        exceptionsList: Signal<NotificationExceptionsList?, NoError>,
+        archivedStickerPacks: Signal<[ArchivedStickerPackItem]?, NoError>,
+        privacySettings: Signal<AccountPrivacySettings?, NoError>,
+        hasTwoStepAuth: Signal<Bool?, NoError>,
+        twoStepAuthData: Signal<TwoStepVerificationAccessConfiguration?, NoError>,
+        activeSessionsContext: Signal<ActiveSessionsContext?, NoError>,
+        webSessionsContext: Signal<WebSessionsContext?, NoError>
+    ) {
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        self.presentationData = presentationData
+        self.presentationDataPromise = Promise(self.presentationData)
+        
+        self.listNode = ListView()
+        self.listNode.backgroundColor = self.presentationData.theme.chatList.backgroundColor
+        self.listNode.isHidden = true
+        self.listNode.accessibilityPageScrolledString = { row, count in
+            return presentationData.strings.VoiceOver_ScrollStatus(row, count).string
+        }
+        
+        self.recentListNode = ListView()
+        self.recentListNode.backgroundColor = self.presentationData.theme.chatList.backgroundColor
+        self.recentListNode.verticalScrollIndicatorColor = self.presentationData.theme.list.scrollIndicatorColor
+        self.recentListNode.accessibilityPageScrolledString = { row, count in
+            return presentationData.strings.VoiceOver_ScrollStatus(row, count).string
+        }
+        
+        self.edgeEffectView = EdgeEffectView()
+        
+        super.init()
+        
+        self.backgroundColor = self.presentationData.theme.chatList.backgroundColor
+        
+        self.addSubnode(self.recentListNode)
+        self.addSubnode(self.listNode)
+        self.view.addSubview(self.edgeEffectView)
+        
+        let interaction = SettingsSearchInteraction(
+            openItem: { item in
+                addRecentSettingsSearchItem(engine: context.engine, item: item.id)
+                openResult(item)
+            },
+            openItemContextMenu: { item, node, rect, gesture in
+                openContextMenu(item, node, rect, gesture)
+            },
+            deleteRecentItem: { id in
+                removeRecentSettingsSearchItem(engine: context.engine, item: id)
+            }
+        )
+        
+        let searchableItems = Promise<[SettingsSearchableItem]>()
+        searchableItems.set(settingsSearchableItems(
+            context: context,
+            notificationExceptionsList: exceptionsList,
+            archivedStickerPacks: archivedStickerPacks,
+            privacySettings: privacySettings,
+            hasTwoStepAuth: hasTwoStepAuth,
+            twoStepAuthData: twoStepAuthData,
+            activeSessionsContext: activeSessionsContext,
+            webSessionsContext: webSessionsContext
+        ))
+        
+        let faqItems = Promise<[SettingsSearchableItem]>()
+        faqItems.set(faqSearchableItems(context: context, resolvedUrl: resolvedFaqUrl, suggestAccountDeletion: false))
+        
+        let queryAndFoundItems = combineLatest(searchableItems.get(), faqSearchableItems(context: context, resolvedUrl: resolvedFaqUrl, suggestAccountDeletion: true))
+        |> mapToSignal { searchableItems, faqSearchableItems -> Signal<(String, [SettingsSearchableItem])?, NoError> in
+            return self.searchQuery.get()
+            |> mapToSignal { query -> Signal<(String, [SettingsSearchableItem])?, NoError> in
+                if let query = query, !query.isEmpty {
+                    let results = searchSettingsItems(items: searchableItems, query: query)
+                    let faqResults = searchSettingsItems(items: faqSearchableItems, query: query)
+                    let finalResults: [SettingsSearchableItem]
+                    //if faqResults.first?.id == .faq(1) {
+                    //    finalResults = faqResults + results
+                    //} else {
+                        finalResults = results + faqResults
+                    //}
+                    return .single((query, finalResults))
+                } else {
+                    return .single(nil)
+                }
+            }
+        }
+        
+        self.recentListNode.isHidden = false
+        
+        let previousRecentlySearchedItemOrder = Atomic<[AnyHashable]>(value: [])
+        let fixedRecentlySearchedItems = settingsSearchRecentItems(engine: context.engine)
+        |> map { recentIds -> [AnyHashable] in
+            var result: [AnyHashable] = []
+            let _ = previousRecentlySearchedItemOrder.modify { current in
+                var updated: [AnyHashable] = []
+                for id in current {
+                    inner: for recentId in recentIds {
+                        if recentId == id {
+                            updated.append(id)
+                            result.append(recentId)
+                            break inner
+                        }
+                    }
+                }
+                for recentId in recentIds.reversed() {
+                    if !updated.contains(recentId) {
+                        updated.insert(recentId, at: 0)
+                        result.insert(recentId, at: 0)
+                    }
+                }
+                return updated
+            }
+            return result
+        }
+        
+        let recentSearchItems = combineLatest(searchableItems.get(), fixedRecentlySearchedItems)
+        |> map { searchableItems, recentItems -> [SettingsSearchableItem] in
+            let searchableItemsMap = searchableItems.reduce([AnyHashable : SettingsSearchableItem]()) { (map, item) -> [AnyHashable: SettingsSearchableItem] in
+                var map = map
+                map[item.id] = item
+                return map
+            }
+            var result: [SettingsSearchableItem] = []
+            for itemId in recentItems {
+                if let searchItem = searchableItemsMap[itemId] {
+                    //if case let .language(id) = searchItem.id, id > 0 {
+                    //} else {
+                        result.append(searchItem)
+                    //}
+                }
+            }
+            return result
+        }
+        
+        let previousRecentItems = Atomic<[SettingsSearchRecentEntry]?>(value: nil)
+        self.recentDisposable = (combineLatest(recentSearchItems, faqItems.get(), self.presentationDataPromise.get())
+        |> deliverOnMainQueue).start(next: { [weak self] recentSearchItems, faqItems, presentationData in
+            if let strongSelf = self {
+                let recentHeader = ChatListSearchItemHeader(type: .recentPeers, theme: presentationData.theme, strings: presentationData.strings, actionTitle: presentationData.strings.WebSearch_RecentSectionClear, action: { _ in
+                    clearRecentSettingsSearchItems(engine: context.engine)
+                })
+                let faqHeader = ChatListSearchItemHeader(type: .faq, theme: presentationData.theme, strings: presentationData.strings)
+                
+                var entries: [SettingsSearchRecentEntry] = []
+                for i in 0 ..< recentSearchItems.count {
+                    entries.append(.recent(i, recentSearchItems[i], recentHeader))
+                }
+                
+                for i in 0 ..< faqItems.count {
+                    entries.append(.faq(i, faqItems[i], faqHeader))
+                }
+                
+                let previousEntries = previousRecentItems.swap(entries)
+                let transition = preparedSettingsSearchContainerRecentTransition(from: previousEntries ?? [], to: entries, account: context.account, theme: presentationData.theme, strings: presentationData.strings, interaction: interaction)
+                strongSelf.enqueueRecentTransition(transition, firstTime: previousEntries == nil)
+            }
+        })
+        
+        let previousEntriesHolder = Atomic<([SettingsSearchEntry], PresentationTheme, PresentationStrings)?>(value: nil)
+        self.searchDisposable.set(combineLatest(queue: .mainQueue(), queryAndFoundItems, self.presentationDataPromise.get()).start(next: { [weak self] queryAndFoundItems, presentationData in
+            guard let strongSelf = self else {
+                return
+            }
+            var currentQuery: String?
+            var entries: [SettingsSearchEntry] = []
+            if let (query, items) = queryAndFoundItems {
+                currentQuery = query
+                var previousIcon: SettingsSearchableItemIcon?
+                for item in items {
+                    var image: UIImage?
+                    if previousIcon != item.icon {
+                        image = item.icon.image()
+                    }
+                    entries.append(.result(index: entries.count, item: item, icon: image))
+                    previousIcon = item.icon
+                }
+            }
+            
+            if !entries.isEmpty || currentQuery == nil {
+                let previousEntriesAndPresentationData = previousEntriesHolder.swap((entries, presentationData.theme, presentationData.strings))
+                let transition = preparedSettingsSearchContainerTransition(theme: presentationData.theme, strings: presentationData.strings, from: previousEntriesAndPresentationData?.0 ?? [], to: entries, interaction: interaction, isSearching: queryAndFoundItems != nil, forceUpdate: previousEntriesAndPresentationData?.1 !== presentationData.theme || previousEntriesAndPresentationData?.2 !== presentationData.strings)
+                strongSelf.enqueueTransition(transition)
+            }
+        }))
+        
+        self.presentationDataDisposable = (context.sharedContext.presentationData
+            |> deliverOnMainQueue).start(next: { [weak self] presentationData in
+                if let strongSelf = self {
+                    let previousTheme = strongSelf.presentationData.theme
+                    let previousStrings = strongSelf.presentationData.strings
+                    
+                    strongSelf.presentationData = presentationData
+                    
+                    if previousTheme !== presentationData.theme || previousStrings !== presentationData.strings {
+                        strongSelf.updateThemeAndStrings(theme: presentationData.theme, strings: presentationData.strings)
+                        strongSelf.presentationDataPromise.set(.single(presentationData))
+                    }
+                }
+            })
+        
+        self.listNode.beganInteractiveDragging = { [weak self] _ in
+            self?.dismissInput?()
+        }
+        
+        self.recentListNode.beganInteractiveDragging = { [weak self] _ in
+            self?.dismissInput?()
+        }
+    }
+    
+    deinit {
+        self.searchDisposable.dispose()
+        self.recentDisposable?.dispose()
+        self.presentationDataDisposable?.dispose()
+    }
+    
+    func updateThemeAndStrings(theme: PresentationTheme, strings: PresentationStrings) {
+        self.listNode.backgroundColor = theme.chatList.backgroundColor
+        self.recentListNode.backgroundColor = theme.chatList.backgroundColor
+        self.recentListNode.verticalScrollIndicatorColor = theme.list.scrollIndicatorColor
+    }
+    
+    public override func searchTextUpdated(text: String) {
+        if text.isEmpty {
+            self.searchQuery.set(.single(nil))
+        } else {
+            self.searchQuery.set(.single(text))
+        }
+    }
+    
+    private func enqueueTransition(_ transition: SettingsSearchContainerTransition) {
+        self.enqueuedTransitions.append(transition)
+        
+        if self.hasValidLayout {
+            while !self.enqueuedTransitions.isEmpty {
+                self.dequeueTransition()
+            }
+        }
+    }
+    
+    private func dequeueTransition() {
+        if let transition = self.enqueuedTransitions.first {
+            self.enqueuedTransitions.remove(at: 0)
+            
+            var options = ListViewDeleteAndInsertOptions()
+            options.insert(.PreferSynchronousDrawing)
+            
+            let isSearching = transition.isSearching
+            self.listNode.transaction(deleteIndices: transition.deletions, insertIndicesAndItems: transition.insertions, updateIndicesAndItems: transition.updates, options: options, updateSizeAndInsets: nil, updateOpaqueState: nil, completion: { [weak self] _ in
+                self?.listNode.isHidden = !isSearching
+            })
+        }
+    }
+    
+    private func enqueueRecentTransition(_ transition: SettingsSearchContainerRecentTransition, firstTime: Bool) {
+        self.enqueuedRecentTransitions.append((transition, firstTime))
+        
+        if self.hasValidLayout {
+            while !self.enqueuedRecentTransitions.isEmpty {
+                self.dequeueRecentTransition()
+            }
+        }
+    }
+    
+    private func dequeueRecentTransition() {
+        if let (transition, firstTime) = self.enqueuedRecentTransitions.first {
+            self.enqueuedRecentTransitions.remove(at: 0)
+            
+            var options = ListViewDeleteAndInsertOptions()
+            if firstTime {
+                options.insert(.PreferSynchronousDrawing)
+            } else {
+                options.insert(.AnimateInsertion)
+            }
+            
+            self.recentListNode.transaction(deleteIndices: transition.deletions, insertIndicesAndItems: transition.insertions, updateIndicesAndItems: transition.updates, options: options, updateSizeAndInsets: nil, updateOpaqueState: nil, completion: { [weak self] _ in
+                self?.recentListNode.backgroundColor = transition.isEmpty ? .clear : self?.presentationData.theme.chatList.backgroundColor
+            })
+        }
+    }
+    
+    public override func containerLayoutUpdated(_ layout: ContainerViewLayout, navigationBarHeight: CGFloat, transition: ContainedViewLayoutTransition) {
+        super.containerLayoutUpdated(layout, navigationBarHeight: navigationBarHeight, transition: transition)
+                
+        let (duration, curve) = listViewAnimationDurationAndCurve(transition: transition)
+        
+        var insets = layout.insets(options: [.input])
+        insets.top += navigationBarHeight
+        insets.left += layout.safeInsets.left
+        insets.right += layout.safeInsets.right
+        
+        self.recentListNode.frame = CGRect(origin: CGPoint(), size: layout.size)
+        self.recentListNode.transaction(deleteIndices: [], insertIndicesAndItems: [], updateIndicesAndItems: [], options: [.Synchronous], scrollToItem: nil, updateSizeAndInsets: ListViewUpdateSizeAndInsets(size: layout.size, insets: insets, duration: duration, curve: curve), stationaryItemRange: nil, updateOpaqueState: nil, completion: { _ in })
+        
+        self.listNode.frame = CGRect(origin: CGPoint(), size: layout.size)
+        self.listNode.transaction(deleteIndices: [], insertIndicesAndItems: [], updateIndicesAndItems: [], options: [.Synchronous], scrollToItem: nil, updateSizeAndInsets: ListViewUpdateSizeAndInsets(size: layout.size, insets: insets, duration: duration, curve: curve), stationaryItemRange: nil, updateOpaqueState: nil, completion: { _ in })
+        
+        if !self.hasValidLayout {
+            self.hasValidLayout = true
+            while !self.enqueuedTransitions.isEmpty {
+                self.dequeueTransition()
+            }
+        }
+        
+        let edgeEffectHeight: CGFloat = insets.bottom + 8.0
+        let edgeEffectFrame = CGRect(origin: CGPoint(x: 0.0, y: layout.size.height - edgeEffectHeight), size: CGSize(width: layout.size.width, height: edgeEffectHeight))
+        transition.updateFrame(view: self.edgeEffectView, frame: edgeEffectFrame)
+        self.edgeEffectView.update(content: self.presentationData.theme.list.plainBackgroundColor, rect: edgeEffectFrame, edge: .bottom, edgeSize: min(edgeEffectHeight, 50.0), transition: ComponentTransition(transition))
+        transition.updateAlpha(layer: self.edgeEffectView.layer, alpha: edgeEffectHeight > 21.0 ? 1.0 : 0.0)
+    }
+    
+    public override func scrollToTop() {
+        let listNodeToScroll: ListView
+        if !self.listNode.isHidden {
+            listNodeToScroll = self.listNode
+        } else {
+            listNodeToScroll = self.recentListNode
+        }
+        listNodeToScroll.transaction(deleteIndices: [], insertIndicesAndItems: [], updateIndicesAndItems: [], options: [.Synchronous, .LowLatency], scrollToItem: ListViewScrollToItem(index: 0, position: .top(0.0), animated: true, curve: .Default(duration: nil), directionHint: .Up), updateSizeAndInsets: nil, stationaryItemRange: nil, updateOpaqueState: nil, completion: { _ in })
+    }
+    
+    @objc func dimTapGesture(_ recognizer: UITapGestureRecognizer) {
+        if case .ended = recognizer.state {
+            self.cancel?()
+        }
+    }
+}
+
+private final class SettingsSearchItemNode: ItemListControllerSearchNode {
+    private let context: AccountContext
+    private var presentationData: PresentationData
+    private var containerLayout: (ContainerViewLayout, CGFloat)?
+    private var searchDisplayController: SearchDisplayController?
+    
+    let pushController: (ViewController) -> Void
+    let presentController: (ViewController, Any?) -> Void
+    let getNavigationController: (() -> NavigationController?)?
+    let resolvedFaqUrl: Signal<ResolvedUrl?, NoError>
+    let exceptionsList: Signal<NotificationExceptionsList?, NoError>
+    let archivedStickerPacks: Signal<[ArchivedStickerPackItem]?, NoError>
+    let privacySettings: Signal<AccountPrivacySettings?, NoError>
+    let hasTwoStepAuth: Signal<Bool?, NoError>
+    let twoStepAuthData: Signal<TwoStepVerificationAccessConfiguration?, NoError>
+    let activeSessionsContext: Signal<ActiveSessionsContext?, NoError>
+    let webSessionsContext: Signal<WebSessionsContext?, NoError>
+    
+    var cancel: () -> Void
+    
+    init(context: AccountContext, cancel: @escaping () -> Void, updateActivity: @escaping(Bool) -> Void, pushController: @escaping (ViewController) -> Void, presentController: @escaping (ViewController, Any?) -> Void, getNavigationController: (() -> NavigationController?)?, resolvedFaqUrl: Signal<ResolvedUrl?, NoError>, exceptionsList: Signal<NotificationExceptionsList?, NoError>, archivedStickerPacks: Signal<[ArchivedStickerPackItem]?, NoError>, privacySettings: Signal<AccountPrivacySettings?, NoError>, hasTwoStepAuth: Signal<Bool?, NoError>, twoStepAuthData: Signal<TwoStepVerificationAccessConfiguration?, NoError>, activeSessionsContext: Signal<ActiveSessionsContext?, NoError>, webSessionsContext: Signal<WebSessionsContext?, NoError>) {
+        self.context = context
+        self.presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        self.cancel = cancel
+        self.pushController = pushController
+        self.presentController = presentController
+        self.getNavigationController = getNavigationController
+        self.resolvedFaqUrl = resolvedFaqUrl
+        self.exceptionsList = exceptionsList
+        self.archivedStickerPacks = archivedStickerPacks
+        self.privacySettings = privacySettings
+        self.hasTwoStepAuth = hasTwoStepAuth
+        self.twoStepAuthData = twoStepAuthData
+        self.activeSessionsContext = activeSessionsContext
+        self.webSessionsContext = webSessionsContext
+        
+        super.init()
+    }
+    
+    func updatePresentationData(_ presentationData: PresentationData) {
+        self.presentationData = presentationData
+        self.searchDisplayController?.updatePresentationData(presentationData)
+    }
+    
+    func activateSearch(placeholderNode: SearchBarPlaceholderNode) {
+        guard let (containerLayout, navigationBarHeight) = self.containerLayout, self.searchDisplayController == nil else {
+            return
+        }
+        
+        self.searchDisplayController = SearchDisplayController(presentationData: self.presentationData, contentNode: SettingsSearchContainerNode(context: self.context, openResult: { [weak self] result in
+            if let strongSelf = self {
+                result.present(strongSelf.context, strongSelf.getNavigationController?(), { [weak self] mode, controller in
+                    if let strongSelf = self {
+                        switch mode {
+                            case .push:
+                                if let controller = controller {
+                                    strongSelf.pushController(controller)
+                                }
+                            case .modal:
+                                if let controller = controller {
+                                    strongSelf.presentController(controller, ViewControllerPresentationArguments(presentationAnimation: .modalSheet, completion: { [weak self] in
+                                        self?.cancel()
+                                    }))
+                                }
+                            case .immediate:
+                                if let controller = controller {
+                                    strongSelf.presentController(controller, nil)
+                                }
+                            case .dismiss:
+                                strongSelf.cancel()
+                        }
+                    }
+                })
+            }
+        }, openContextMenu: { _, _, _, _ in }, resolvedFaqUrl: self.resolvedFaqUrl, exceptionsList: self.exceptionsList, archivedStickerPacks: self.archivedStickerPacks, privacySettings: self.privacySettings, hasTwoStepAuth: self.hasTwoStepAuth, twoStepAuthData: self.twoStepAuthData, activeSessionsContext: self.activeSessionsContext, webSessionsContext: self.webSessionsContext), cancel: { [weak self] in
+            self?.cancel()
+        }, fieldStyle: placeholderNode.fieldStyle)
+        
+        self.searchDisplayController?.containerLayoutUpdated(containerLayout, navigationBarHeight: navigationBarHeight, transition: .immediate)
+        self.searchDisplayController?.activate(insertSubnode: { [weak self, weak placeholderNode] subnode, isSearchBar in
+            if let strongSelf = self, let strongPlaceholderNode = placeholderNode {
+                if isSearchBar {
+                    strongPlaceholderNode.supernode?.insertSubnode(subnode, aboveSubnode: strongPlaceholderNode)
+                } else {
+                    strongSelf.addSubnode(subnode)
+                }
+            }
+        }, placeholder: placeholderNode)
+    }
+    
+    func deactivateSearch(placeholderNode: SearchBarPlaceholderNode) {
+        if let searchDisplayController = self.searchDisplayController {
+            searchDisplayController.deactivate(placeholder: placeholderNode)
+            self.searchDisplayController = nil
+        }
+    }
+    
+    var isSearching: Bool {
+        return self.searchDisplayController != nil
+    }
+    
+    override func scrollToTop() {
+        self.searchDisplayController?.contentNode.scrollToTop()
+    }
+    
+    override func queryUpdated(_ query: String) {
+    }
+    
+    override func updateLayout(layout: ContainerViewLayout, navigationBarHeight: CGFloat, transition: ContainedViewLayoutTransition) {
+        self.containerLayout = (layout, navigationBarHeight)
+        
+        if let searchDisplayController = self.searchDisplayController {
+            searchDisplayController.containerLayoutUpdated(layout, navigationBarHeight: navigationBarHeight, transition: transition)
+        }
+    }
+    
+    override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+        if let searchDisplayController = self.searchDisplayController, let result = searchDisplayController.contentNode.hitTest(self.view.convert(point, to: searchDisplayController.contentNode.view), with: event) {
+            return result
+        }
+        
+        return super.hitTest(point, with: event)
+    }
+}
+

submodules/SettingsUI/Sources/Search/SettingsSearchRecentItem.swift

@@ -0,0 +1,288 @@
+import Foundation
+import UIKit
+import AsyncDisplayKit
+import Postbox
+import Display
+import SwiftSignalKit
+import TelegramCore
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+
+private enum RevealOptionKey: Int32 {
+    case delete
+}
+
+class SettingsSearchRecentItem: ListViewItem {
+    let theme: PresentationTheme
+    let strings: PresentationStrings
+    let account: Account
+    let title: String
+    let breadcrumbs: [String]
+    let isFaq: Bool
+    let action: () -> Void
+    let deleted: () -> Void
+    
+    let header: ListViewItemHeader?
+    
+    init(account: Account, theme: PresentationTheme, strings: PresentationStrings, title: String, breadcrumbs: [String], isFaq: Bool, action: @escaping () -> Void, deleted: @escaping () -> Void, header: ListViewItemHeader) {
+        self.theme = theme
+        self.strings = strings
+        self.account = account
+        self.title = title
+        self.breadcrumbs = breadcrumbs
+        self.isFaq = isFaq
+        self.action = action
+        self.deleted = deleted
+        self.header = header
+    }
+    
+    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 = SettingsSearchRecentItemNode()
+            let makeLayout = node.asyncLayout()
+            
+            var previousHeader: ListViewItemHeader?
+            if let previousItem = previousItem as? SettingsSearchRecentItem {
+                previousHeader = previousItem.header
+            }
+            var nextHeader: ListViewItemHeader?
+            if let nextItem = nextItem as? SettingsSearchRecentItem {
+                nextHeader = nextItem.header
+            }
+            
+            let (nodeLayout, nodeApply) = makeLayout(self, params, nextItem == nil || nextHeader?.id != self.header?.id, !(previousItem is SettingsSearchRecentItem) || previousHeader?.id != self.header?.id)
+            node.contentSize = nodeLayout.contentSize
+            node.insets = nodeLayout.insets
+            
+            completion(node, nodeApply)
+        }
+    }
+    
+    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? SettingsSearchRecentItemNode {
+                let layout = nodeValue.asyncLayout()
+                async {
+                    var previousHeader: ListViewItemHeader?
+                    if let previousItem = previousItem as? SettingsSearchRecentItem {
+                        previousHeader = previousItem.header
+                    }
+                    var nextHeader: ListViewItemHeader?
+                    if let nextItem = nextItem as? SettingsSearchRecentItem {
+                        nextHeader = nextItem.header
+                    }
+                    
+                    let (nodeLayout, apply) = layout(self, params, nextItem == nil || nextHeader?.id != self.header?.id, !(previousItem is SettingsSearchRecentItem) || previousHeader?.id != self.header?.id)
+                    Queue.mainQueue().async {
+                        completion(nodeLayout, { info in
+                            apply().1(info)
+                        })
+                    }
+                }
+            }
+        }
+    }
+    
+    var selectable: Bool {
+        return true
+    }
+    
+    func selected(listView: ListView) {
+        listView.clearHighlightAnimated(true)
+        self.action()
+    }
+}
+
+private let titleFont = Font.regular(17.0)
+private let subtitleFont = Font.regular(13.0)
+
+class SettingsSearchRecentItemNode: ItemListRevealOptionsItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let separatorNode: ASDisplayNode
+    private let highlightedBackgroundNode: ASDisplayNode
+    private let titleNode: TextNode
+    private let subtitleNode: TextNode
+    
+    private var item: SettingsSearchRecentItem?
+    private var layoutParams: ListViewItemLayoutParams?
+    
+    required init() {
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        
+        self.separatorNode = ASDisplayNode()
+        self.separatorNode.isLayerBacked = true
+        
+        self.highlightedBackgroundNode = ASDisplayNode()
+        self.highlightedBackgroundNode.isLayerBacked = true
+        
+        self.titleNode = TextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        self.titleNode.contentMode = .left
+        self.titleNode.contentsScale = UIScreenScale
+        
+        self.subtitleNode = TextNode()
+        self.subtitleNode.isUserInteractionEnabled = false
+        self.subtitleNode.contentMode = .left
+        self.subtitleNode.contentsScale = UIScreenScale
+        
+        super.init(layerBacked: false, rotated: false, seeThrough: false)
+        
+        self.addSubnode(self.backgroundNode)
+        self.addSubnode(self.separatorNode)
+        self.addSubnode(self.titleNode)
+        self.addSubnode(self.subtitleNode)
+    }
+    
+    override func layoutForParams(_ params: ListViewItemLayoutParams, item: ListViewItem, previousItem: ListViewItem?, nextItem: ListViewItem?) {
+        if let item = self.item {
+            let makeLayout = self.asyncLayout()
+            let (nodeLayout, nodeApply) = makeLayout(item, params, nextItem == nil, previousItem == nil)
+            self.contentSize = nodeLayout.contentSize
+            self.insets = nodeLayout.insets
+            let _ = nodeApply()
+        }
+    }
+    
+    override func setHighlighted(_ highlighted: Bool, at point: CGPoint, animated: Bool) {
+        super.setHighlighted(highlighted, at: point, animated: animated)
+        
+        if highlighted {
+            self.highlightedBackgroundNode.alpha = 1.0
+            if self.highlightedBackgroundNode.supernode == nil {
+                self.insertSubnode(self.highlightedBackgroundNode, aboveSubnode: self.separatorNode)
+            }
+        } else {
+            if self.highlightedBackgroundNode.supernode != nil {
+                if animated {
+                    self.highlightedBackgroundNode.layer.animateAlpha(from: self.highlightedBackgroundNode.alpha, to: 0.0, duration: 0.4, completion: { [weak self] completed in
+                        if let strongSelf = self {
+                            if completed {
+                                strongSelf.highlightedBackgroundNode.removeFromSupernode()
+                            }
+                        }
+                    })
+                    self.highlightedBackgroundNode.alpha = 0.0
+                } else {
+                    self.highlightedBackgroundNode.removeFromSupernode()
+                }
+            }
+        }
+    }
+    
+    func asyncLayout() -> (_ item: SettingsSearchRecentItem, _ params: ListViewItemLayoutParams, _ last: Bool, _ firstWithHeader: Bool) -> (ListViewItemNodeLayout, () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        let makeSubtitleLayout = TextNode.asyncLayout(self.subtitleNode)
+        
+        let currentItem = self.item
+        
+        return { [weak self] item, params, last, firstWithHeader in
+            let leftInset: CGFloat = 15.0 + params.leftInset
+            let rightInset: CGFloat = params.rightInset
+            
+            let (titleLayout, titleApply) = makeTitleLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.title, font: titleFont, textColor: item.theme.list.itemPrimaryTextColor), backgroundColor: nil, maximumNumberOfLines: 2, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - 16.0 - rightInset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            let subtitle = item.breadcrumbs.joined(separator: " → ")
+            
+            let (subtitleLayout, subtitleApply) = makeSubtitleLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: subtitle, font: subtitleFont, textColor: item.theme.list.itemPrimaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - 16.0 - rightInset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            var height: CGFloat = 30.0 + titleLayout.size.height
+            if !subtitle.isEmpty {
+                height += 9.0
+            }
+            
+            let contentSize = CGSize(width: params.width, height: height)
+            let nodeLayout = ListViewItemNodeLayout(contentSize: contentSize, insets: UIEdgeInsets(top: firstWithHeader ? 29.0 : 0.0, left: 0.0, bottom: 0.0, right: 0.0))
+            
+            return (nodeLayout, { [weak self] in
+                var updatedTheme: PresentationTheme?
+                if currentItem?.theme !== item.theme {
+                    updatedTheme = item.theme
+                }
+                
+                return (nil, { _ in
+                    if let strongSelf = self {
+                        strongSelf.item = item
+                        strongSelf.layoutParams = params
+                        
+                        if let _ = updatedTheme {
+                            strongSelf.separatorNode.backgroundColor = item.theme.list.itemPlainSeparatorColor
+                            strongSelf.backgroundNode.backgroundColor = item.theme.list.plainBackgroundColor
+                            strongSelf.highlightedBackgroundNode.backgroundColor = item.theme.list.itemHighlightedBackgroundColor
+                        }
+                        
+                        let _ = titleApply()
+                        let _ = subtitleApply()
+                        
+                        let titleY: CGFloat = subtitle.isEmpty ? 16.0 - UIScreenPixel : 11.0
+                        strongSelf.titleNode.frame = CGRect(origin: CGPoint(x: leftInset, y: titleY), size: titleLayout.size)
+                        strongSelf.subtitleNode.frame = CGRect(origin: CGPoint(x: leftInset, y: titleY + titleLayout.size.height + 1.0), size: subtitleLayout.size)
+                        
+                        let separatorHeight = UIScreenPixel
+                        let topHighlightInset: CGFloat = (firstWithHeader || !nodeLayout.insets.top.isZero) ? 0.0 : separatorHeight
+                        
+                        strongSelf.backgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: 0.0), size: CGSize(width: nodeLayout.contentSize.width, height: nodeLayout.contentSize.height))
+                        strongSelf.highlightedBackgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -topHighlightInset), size: CGSize(width: nodeLayout.size.width, height: nodeLayout.contentSize.height + topHighlightInset))
+                        strongSelf.separatorNode.frame = CGRect(origin: CGPoint(x: leftInset, y: nodeLayout.contentSize.height - separatorHeight), size: CGSize(width: nodeLayout.size.width, height: separatorHeight))
+                        strongSelf.separatorNode.isHidden = last
+                        
+                        strongSelf.updateLayout(size: nodeLayout.contentSize, leftInset: params.leftInset, rightInset: params.rightInset)
+                        
+                        var revealOptions: [ItemListRevealOption] = []
+                        if item.isFaq {
+                        } else {
+                            revealOptions.append(ItemListRevealOption(key: RevealOptionKey.delete.rawValue, title: item.strings.Common_Delete, icon: .none, color: item.theme.list.itemDisclosureActions.destructive.fillColor, textColor: item.theme.list.itemDisclosureActions.destructive.foregroundColor))
+                        }
+                        strongSelf.setRevealOptions((left: [], right: revealOptions))
+                    }
+                })
+            })
+        }
+    }
+    
+    override func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: duration * 0.5)
+    }
+    
+    override func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: duration * 0.5, removeOnCompletion: false)
+    }
+    
+    override public func headers() -> [ListViewItemHeader]? {
+        if let item = self.item {
+            return item.header.flatMap { [$0] }
+        } else {
+            return nil
+        }
+    }
+    
+    override func updateRevealOffset(offset: CGFloat, transition: ContainedViewLayoutTransition) {
+        super.updateRevealOffset(offset: offset, transition: transition)
+        
+        if let params = self.layoutParams {
+            let leftInset: CGFloat = 15.0 + params.leftInset
+        
+            var titleFrame = self.titleNode.frame
+            titleFrame.origin.x = leftInset + offset
+            transition.updateFrame(node: self.titleNode, frame: titleFrame)
+            
+            var subtitleFrame = self.subtitleNode.frame
+            subtitleFrame.origin.x = leftInset + offset
+            transition.updateFrame(node: self.subtitleNode, frame: subtitleFrame)
+        }
+    }
+    
+    override func revealOptionSelected(_ option: ItemListRevealOption, animated: Bool) {
+        if let item = self.item {
+            switch option.key {
+            case RevealOptionKey.delete.rawValue:
+                item.deleted()
+            default:
+                break
+            }
+        }
+        self.setRevealOptionsOpened(false, animated: true)
+        self.revealOptionsInteractivelyClosed()
+    }
+}

submodules/SettingsUI/Sources/Search/SettingsSearchRecentQueries.swift

@@ -0,0 +1,73 @@
+import Foundation
+import UIKit
+import Postbox
+import TelegramCore
+import SwiftSignalKit
+import TelegramUIPreferences
+
+private struct SettingsSearchRecentQueryItemId {
+    public let rawValue: MemoryBuffer
+    
+    var value: Int64 {
+        return self.rawValue.makeData().withUnsafeBytes { buffer -> Int64 in
+            guard let bytes = buffer.baseAddress?.assumingMemoryBound(to: Int64.self) else {
+                return 0
+            }
+            return bytes.pointee
+        }
+    }
+    
+    init(_ rawValue: MemoryBuffer) {
+        self.rawValue = rawValue
+    }
+    
+    init(_ value: Int64) {
+        var value = value
+        self.rawValue = MemoryBuffer(data: Data(bytes: &value, count: MemoryLayout.size(ofValue: value)))
+    }
+}
+
+public final class RecentSettingsSearchQueryItem: Codable {
+    public init() {
+    }
+    
+    public init(from decoder: Decoder) throws {
+    }
+    
+    public func encode(to encoder: Encoder) throws {
+    }
+}
+
+func addRecentSettingsSearchItem(engine: TelegramEngine, item: AnyHashable) {
+    guard let id = item.base as? String, let data = id.data(using: .ascii) else {
+        return
+    }
+    let itemId = MemoryBuffer(data: data)
+    let _ = engine.orderedLists.addOrMoveToFirstPosition(collectionId: ApplicationSpecificOrderedItemListCollectionId.settingsSearchRecentItems, id: itemId, item: RecentSettingsSearchQueryItem(), removeTailIfCountExceeds: 100).start()
+}
+
+func removeRecentSettingsSearchItem(engine: TelegramEngine, item: AnyHashable) {
+    guard let id = item.base as? String, let data = id.data(using: .ascii) else {
+        return
+    }
+    let itemId = MemoryBuffer(data: data)
+    let _ = engine.orderedLists.removeItem(collectionId: ApplicationSpecificOrderedItemListCollectionId.settingsSearchRecentItems, id: itemId).start()
+}
+
+func clearRecentSettingsSearchItems(engine: TelegramEngine) {
+    let _ = engine.orderedLists.clear(collectionId: ApplicationSpecificOrderedItemListCollectionId.settingsSearchRecentItems).start()
+}
+
+func settingsSearchRecentItems(engine: TelegramEngine) -> Signal<[AnyHashable], NoError> {
+    return engine.data.subscribe(TelegramEngine.EngineData.Item.OrderedLists.ListItems(collectionId: ApplicationSpecificOrderedItemListCollectionId.settingsSearchRecentItems))
+    |> map { items -> [AnyHashable] in
+        var result: [AnyHashable] = []
+        for item in items {
+            let data = item.id.makeData()
+            if let id = String(data: data, encoding: .utf8) {
+                result.append(id)
+            }
+        }
+        return result
+    }
+}

submodules/SettingsUI/Sources/Search/SettingsSearchResultItem.swift

@@ -0,0 +1,355 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+
+class SettingsSearchResultItem: ListViewItem, ItemListItem {
+    let theme: PresentationTheme
+    let strings: PresentationStrings
+    let item: SettingsSearchableItem
+    let icon: UIImage?
+    let interaction: SettingsSearchInteraction
+    let sectionId: ItemListSectionId
+    
+    init(theme: PresentationTheme, strings: PresentationStrings, item: SettingsSearchableItem, icon: UIImage?, interaction: SettingsSearchInteraction, sectionId: ItemListSectionId) {
+        self.theme = theme
+        self.strings = strings
+        self.item = item
+        self.icon = icon
+        self.interaction = interaction
+        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 = SettingsSearchResultItemNode()
+            var neighbors = itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem)
+            if previousItem == nil || self.isAlwaysPlain {
+                neighbors.top = .sameSection(alwaysPlain: false)
+            }
+            let (layout, apply) = node.asyncLayout()(self, params, neighbors)
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply(false) })
+                })
+            }
+        }
+    }
+    
+    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? SettingsSearchResultItemNode {
+                let makeLayout = nodeValue.asyncLayout()
+                
+                async {
+                    var neighbors = itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem)
+                    if previousItem == nil || self.isAlwaysPlain {
+                        neighbors.top = .sameSection(alwaysPlain: false)
+                    }
+                    let (layout, apply) = makeLayout(self, params, neighbors)
+                    Queue.mainQueue().async {
+                        completion(layout, { _ in
+                            apply(animation.isAnimated)
+                        })
+                    }
+                }
+            }
+        }
+    }
+    
+    var selectable: Bool = true
+    
+    func selected(listView: ListView){
+        listView.clearHighlightAnimated(true)
+        self.interaction.openItem(self.item)
+    }
+}
+
+private let titleFont = Font.regular(17.0)
+private let subtitleFont = Font.regular(13.0)
+
+class SettingsSearchResultItemNode: ListViewItemNode {
+    private let contextSourceNode: ContextExtractedContentContainingNode
+    private let containerNode: ContextControllerSourceNode
+    private let extractedBackgroundImageNode: ASImageNode
+    
+    private var extractedRect: CGRect?
+    private var nonExtractedRect: CGRect?
+    
+    private let offsetContainerNode: ASDisplayNode
+    
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let highlightedBackgroundNode: ASDisplayNode
+    
+    private let iconNode: ASImageNode
+    private let titleNode: TextNode
+    private let subtitleNode: TextNode
+    
+    private var item: SettingsSearchResultItem?
+    private var layoutParams: (ListViewItemLayoutParams, ItemListNeighbors)?
+    
+    init() {
+        self.contextSourceNode = ContextExtractedContentContainingNode()
+        self.containerNode = ContextControllerSourceNode()
+        
+        self.extractedBackgroundImageNode = ASImageNode()
+        self.extractedBackgroundImageNode.displaysAsynchronously = false
+        self.extractedBackgroundImageNode.alpha = 0.0
+        
+        self.offsetContainerNode = ASDisplayNode()
+        
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        
+        self.topStripeNode = ASDisplayNode()
+        self.topStripeNode.isLayerBacked = true
+        
+        self.bottomStripeNode = ASDisplayNode()
+        self.bottomStripeNode.isLayerBacked = true
+        
+        self.iconNode = ASImageNode()
+        self.iconNode.isLayerBacked = true
+        self.iconNode.displayWithoutProcessing = true
+        self.iconNode.displaysAsynchronously = false
+        
+        self.titleNode = TextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        self.titleNode.contentMode = .left
+        self.titleNode.contentsScale = UIScreenScale
+        
+        self.subtitleNode = TextNode()
+        self.subtitleNode.isUserInteractionEnabled = false
+        self.subtitleNode.contentMode = .left
+        self.subtitleNode.contentsScale = UIScreenScale
+        
+        self.highlightedBackgroundNode = ASDisplayNode()
+        self.highlightedBackgroundNode.isLayerBacked = true
+        
+        super.init(layerBacked: false, rotated: false, seeThrough: false)
+        
+        self.containerNode.addSubnode(self.contextSourceNode)
+        self.containerNode.targetNodeForActivationProgress = self.contextSourceNode.contentNode
+        self.addSubnode(self.containerNode)
+        
+        self.contextSourceNode.contentNode.addSubnode(self.extractedBackgroundImageNode)
+        self.contextSourceNode.contentNode.addSubnode(self.offsetContainerNode)
+        
+        self.offsetContainerNode.addSubnode(self.iconNode)
+        self.offsetContainerNode.addSubnode(self.titleNode)
+        self.offsetContainerNode.addSubnode(self.subtitleNode)
+        
+        self.containerNode.activated = { [weak self] gesture, _ in
+            guard let strongSelf = self, let item = strongSelf.item else {
+                return
+            }
+
+            cancelParentGestures(view: strongSelf.view)
+            
+            item.interaction.openItemContextMenu(item.item, strongSelf.contextSourceNode, strongSelf.contextSourceNode.bounds, gesture)
+        }
+        
+        self.contextSourceNode.willUpdateIsExtractedToContextPreview = { [weak self] isExtracted, transition in
+            guard let strongSelf = self, let item = strongSelf.item else {
+                return
+            }
+            
+            if isExtracted {
+                strongSelf.extractedBackgroundImageNode.image = generateStretchableFilledCircleImage(diameter: 52.0, color: item.theme.list.plainBackgroundColor)
+            }
+            
+            if let extractedRect = strongSelf.extractedRect, let nonExtractedRect = strongSelf.nonExtractedRect {
+                let rect = isExtracted ? extractedRect : nonExtractedRect
+                transition.updateFrame(node: strongSelf.extractedBackgroundImageNode, frame: rect)
+            }
+            
+            transition.updateSublayerTransformOffset(layer: strongSelf.offsetContainerNode.layer, offset: CGPoint(x: isExtracted ? 12.0 : 0.0, y: 0.0))
+            transition.updateAlpha(node: strongSelf.extractedBackgroundImageNode, alpha: isExtracted ? 1.0 : 0.0, completion: { _ in
+                if !isExtracted {
+                    self?.extractedBackgroundImageNode.image = nil
+                }
+            })
+        }
+    }
+    
+    func asyncLayout() -> (_ item: SettingsSearchResultItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, (Bool) -> Void) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        let makeSubtitleLayout = TextNode.asyncLayout(self.subtitleNode)
+        
+        let currentItem = self.item
+        
+        return { item, params, neighbors in
+            var leftInset: CGFloat = params.leftInset
+            let contentInset: CGFloat = 60.0
+            
+            let insets = itemListNeighborsGroupedInsets(neighbors, params)
+            
+            leftInset += contentInset
+            
+            let (titleLayout, titleApply) = makeTitleLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.item.title, font: titleFont, textColor: item.theme.list.itemPrimaryTextColor), backgroundColor: nil, maximumNumberOfLines: 2, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - 16.0, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            let subtitle = item.item.breadcrumbs.joined(separator: " → ")
+            
+            let (subtitleLayout, subtitleApply) = makeSubtitleLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: subtitle, font: subtitleFont, textColor: item.theme.list.itemPrimaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - 16.0, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            let separatorHeight = UIScreenPixel
+            
+            var updateIconImage: UIImage?
+            var updatedTheme: PresentationTheme?
+            
+            if currentItem?.theme !== item.theme {
+                updatedTheme = item.theme
+            }
+            
+            if currentItem?.icon !== item.icon {
+                updateIconImage = item.icon
+            }
+            
+            var height: CGFloat = 30.0 + titleLayout.size.height
+            if !subtitle.isEmpty {
+                height += 9.0
+            }
+            
+            let contentSize = CGSize(width: params.width, height: height)
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            return (layout, { [weak self] animated in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    strongSelf.layoutParams = (params, neighbors)
+                    
+                    let transition: ContainedViewLayoutTransition
+                    if animated {
+                        transition = .animated(duration: 0.4, curve: .spring)
+                    } else {
+                        transition = .immediate
+                    }
+                    
+                    if let updateIconImage = updateIconImage {
+                        strongSelf.iconNode.image = updateIconImage
+                    } else if item.icon == nil {
+                        strongSelf.iconNode.image = nil
+                    }
+                    
+                    if let _ = updatedTheme {
+                        strongSelf.topStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                        strongSelf.bottomStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                        strongSelf.backgroundNode.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+                        strongSelf.highlightedBackgroundNode.backgroundColor = item.theme.list.itemHighlightedBackgroundColor
+                    }
+                    
+                    let _ = titleApply()
+                    let _ = subtitleApply()
+                    
+                    if let image = strongSelf.iconNode.image {
+                        transition.updateFrame(node: strongSelf.iconNode, frame: CGRect(origin: CGPoint(x: params.leftInset + floor((contentInset - image.size.width) / 2.0), y: floor((contentSize.height - image.size.height) / 2.0)), size: image.size))
+                    }
+                    
+                    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)
+                    }
+                    switch neighbors.top {
+                        case .sameSection(false):
+                            strongSelf.topStripeNode.isHidden = true
+                        default:
+                            strongSelf.topStripeNode.isHidden = false
+                    }
+                    let bottomStripeInset: CGFloat
+                    switch neighbors.bottom {
+                    case .sameSection(false):
+                        bottomStripeInset = leftInset
+                    default:
+                        bottomStripeInset = 0.0
+                    }
+                    
+                    strongSelf.containerNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.contextSourceNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.offsetContainerNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.contextSourceNode.contentNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    
+                    let nonExtractedRect = CGRect(origin: CGPoint(), size: CGSize(width: layout.contentSize.width - 16.0, height: layout.contentSize.height))
+                    let extractedRect = CGRect(origin: CGPoint(), size: layout.contentSize).insetBy(dx: 16.0 + params.leftInset, dy: 0.0)
+                    strongSelf.extractedRect = extractedRect
+                    strongSelf.nonExtractedRect = nonExtractedRect
+                    
+                    if strongSelf.contextSourceNode.isExtractedToContextPreview {
+                        strongSelf.extractedBackgroundImageNode.frame = extractedRect
+                    } else {
+                        strongSelf.extractedBackgroundImageNode.frame = nonExtractedRect
+                    }
+                    strongSelf.contextSourceNode.contentRect = extractedRect
+                    
+                    strongSelf.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.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 titleY: CGFloat = subtitle.isEmpty ? 16.0 - UIScreenPixel : 11.0
+                    transition.updateFrame(node: strongSelf.titleNode, frame: CGRect(origin: CGPoint(x: leftInset, y: titleY), size: titleLayout.size))
+                    transition.updateFrame(node: strongSelf.subtitleNode, frame: CGRect(origin: CGPoint(x: leftInset, y: titleY + titleLayout.size.height + 1.0), size: subtitleLayout.size))
+                    
+                    strongSelf.highlightedBackgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -UIScreenPixel), size: CGSize(width: params.width, height: contentSize.height + UIScreenPixel + UIScreenPixel))
+                }
+            })
+        }
+    }
+    
+    override func setHighlighted(_ highlighted: Bool, at point: CGPoint, animated: Bool) {
+        super.setHighlighted(highlighted, at: point, animated: animated)
+        
+        if highlighted {
+            self.highlightedBackgroundNode.alpha = 1.0
+            if self.highlightedBackgroundNode.supernode == nil {
+                var anchorNode: ASDisplayNode?
+                if self.bottomStripeNode.supernode != nil {
+                    anchorNode = self.bottomStripeNode
+                } else if self.topStripeNode.supernode != nil {
+                    anchorNode = self.topStripeNode
+                } else if self.backgroundNode.supernode != nil {
+                    anchorNode = self.backgroundNode
+                }
+                if let anchorNode = anchorNode {
+                    self.insertSubnode(self.highlightedBackgroundNode, aboveSubnode: anchorNode)
+                } else {
+                    self.addSubnode(self.highlightedBackgroundNode)
+                }
+            }
+        } else {
+            if self.highlightedBackgroundNode.supernode != nil {
+                if animated {
+                    self.highlightedBackgroundNode.layer.animateAlpha(from: self.highlightedBackgroundNode.alpha, to: 0.0, duration: 0.4, completion: { [weak self] completed in
+                        if let strongSelf = self {
+                            if completed {
+                                strongSelf.highlightedBackgroundNode.removeFromSupernode()
+                            }
+                        }
+                    })
+                    self.highlightedBackgroundNode.alpha = 0.0
+                } else {
+                    self.highlightedBackgroundNode.removeFromSupernode()
+                }
+            }
+        }
+    }
+    
+    override func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+}