Merge commit '7621e2f8dec938cf48181c8b10afc9b01f444e68' into beta

submodules/TelegramUI/Components/Gifts/GiftStoreScreen/BUILD

@@ -0,0 +1,53 @@
+load("@build_bazel_rules_swift//swift:swift.bzl", "swift_library")
+
+swift_library(
+    name = "GiftStoreScreen",
+    module_name = "GiftStoreScreen",
+    srcs = glob([
+        "Sources/**/*.swift",
+    ]),
+    copts = [
+        "-warnings-as-errors",
+    ],
+    deps = [
+        "//submodules/AsyncDisplayKit",
+        "//submodules/Display",
+        "//submodules/Postbox",
+        "//submodules/TelegramCore",
+        "//submodules/SSignalKit/SwiftSignalKit",
+        "//submodules/ComponentFlow",
+        "//submodules/Components/ViewControllerComponent",
+        "//submodules/Components/ComponentDisplayAdapters",
+        "//submodules/Components/MultilineTextComponent",
+        "//submodules/Components/BalancedTextComponent",
+        "//submodules/TelegramPresentationData",
+        "//submodules/AccountContext",
+        "//submodules/AppBundle",
+        "//submodules/ItemListUI",
+        "//submodules/TelegramStringFormatting",
+        "//submodules/PresentationDataUtils",
+        "//submodules/Components/SheetComponent",
+        "//submodules/UndoUI",
+        "//submodules/TextFormat",
+        "//submodules/TelegramUI/Components/ListSectionComponent",
+        "//submodules/TelegramUI/Components/ListActionItemComponent",
+        "//submodules/TelegramUI/Components/ScrollComponent",
+        "//submodules/TelegramUI/Components/PlainButtonComponent",
+        "//submodules/TelegramUI/Components/Premium/PremiumStarComponent",
+        "//submodules/Components/BlurredBackgroundComponent",
+        "//submodules/TelegramUI/Components/ButtonComponent",
+        "//submodules/Components/BundleIconComponent",
+        "//submodules/TelegramUI/Components/Gifts/GiftItemComponent",
+        "//submodules/ConfettiEffect",
+        "//submodules/InAppPurchaseManager",
+        "//submodules/TelegramUI/Components/TabSelectorComponent",
+        "//submodules/TelegramUI/Components/Gifts/GiftSetupScreen",
+        "//submodules/TelegramUI/Components/Gifts/GiftViewScreen",
+        "//submodules/TelegramUI/Components/LottieComponent",
+        "//submodules/TelegramUI/Components/TextFieldComponent",
+        "//submodules/TelegramUI/Components/Gifts/GiftLoadingShimmerView",
+    ],
+    visibility = [
+        "//visibility:public",
+    ],
+)

submodules/TelegramUI/Components/Gifts/GiftStoreScreen/Sources/FilterSelectorComponent.swift

@@ -0,0 +1,472 @@
+import Foundation
+import UIKit
+import Display
+import ComponentFlow
+import SwiftSignalKit
+import PlainButtonComponent
+import MultilineTextComponent
+import BundleIconComponent
+import TextFormat
+import AccountContext
+import LottieComponent
+
+public final class FilterSelectorComponent: Component {
+    public struct Colors: Equatable {
+        public var foreground: UIColor
+        public var background: UIColor
+        
+        public init(
+            foreground: UIColor,
+            background: UIColor
+        ) {
+            self.foreground = foreground
+            self.background = background
+        }
+    }
+    
+    public struct Item: Equatable {
+        public var id: AnyHashable
+        public var index: Int
+        public var iconName: String?
+        public var title: String
+        public var action: (UIView) -> Void
+        
+        public init(
+            id: AnyHashable,
+            index: Int = 0,
+            iconName: String? = nil,
+            title: String,
+            action: @escaping (UIView) -> Void
+        ) {
+            self.id = id
+            self.index = index
+            self.iconName = iconName
+            self.title = title
+            self.action = action
+        }
+        
+        public static func ==(lhs: Item, rhs: Item) -> Bool {
+            return lhs.id == rhs.id && lhs.index == rhs.index && lhs.iconName == rhs.iconName && lhs.title == rhs.title
+        }
+    }
+    
+    public let context: AccountContext?
+    public let colors: Colors
+    public let items: [Item]
+    public let selectedItemId: AnyHashable?
+    
+    public init(
+        context: AccountContext? = nil,
+        colors: Colors,
+        items: [Item],
+        selectedItemId: AnyHashable?
+    ) {
+        self.context = context
+        self.colors = colors
+        self.items = items
+        self.selectedItemId = selectedItemId
+    }
+    
+    public static func ==(lhs: FilterSelectorComponent, rhs: FilterSelectorComponent) -> Bool {
+        if lhs.context !== rhs.context {
+            return false
+        }
+        if lhs.colors != rhs.colors {
+            return false
+        }
+        if lhs.items != rhs.items {
+            return false
+        }
+        if lhs.selectedItemId != rhs.selectedItemId {
+            return false
+        }
+        return true
+    }
+    
+    private final class VisibleItem {
+        let title = ComponentView<Empty>()
+        
+        init() {
+        }
+    }
+    
+    public final class View: UIScrollView {
+        private var component: FilterSelectorComponent?
+        private weak var state: EmptyComponentState?
+        
+        private var visibleItems: [AnyHashable: VisibleItem] = [:]
+        
+        override init(frame: CGRect) {
+            super.init(frame: frame)
+            
+            self.showsVerticalScrollIndicator = false
+            self.showsHorizontalScrollIndicator = false
+            self.scrollsToTop = false
+            self.delaysContentTouches = false
+            self.canCancelContentTouches = true
+            self.contentInsetAdjustmentBehavior = .never
+            self.alwaysBounceVertical = false
+            self.clipsToBounds = false
+        }
+        
+        required init?(coder: NSCoder) {
+            fatalError("init(coder:) has not been implemented")
+        }
+        
+        deinit {
+        }
+        
+        override public func touchesShouldCancel(in view: UIView) -> Bool {
+            return true
+        }
+        
+        func animateIn() {
+            for (_, item) in self.visibleItems {
+                if let itemView = item.title.view {
+                    itemView.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
+                    itemView.layer.animateScale(from: 0.1, to: 1.0, duration: 0.2)
+                }
+            }
+        }
+        
+        func update(component: FilterSelectorComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
+            self.component = component
+            self.state = state
+            
+            let baseHeight: CGFloat = 28.0
+            
+            var spacing: CGFloat = 6.0
+            
+            let itemFont = Font.semibold(14.0)
+            let allowScroll = true
+            
+            var innerContentWidth: CGFloat = 0.0
+            
+            var validIds: [AnyHashable] = []
+            var index = 0
+            var itemViews: [AnyHashable: (VisibleItem, CGSize, ComponentTransition)] = [:]
+            
+            for item in component.items {
+                var itemTransition = transition
+                let itemView: VisibleItem
+                if let current = self.visibleItems[item.id] {
+                    itemView = current
+                } else {
+                    itemView = VisibleItem()
+                    self.visibleItems[item.id] = itemView
+                    itemTransition = itemTransition.withAnimation(.none)
+                }
+                
+                let itemId = item.id
+                validIds.append(itemId)
+                
+                let itemSize = itemView.title.update(
+                    transition: transition,
+                    component: AnyComponent(PlainButtonComponent(
+                        content: AnyComponent(ItemComponent(
+                            context: component.context,
+                            index: item.index,
+                            iconName: item.iconName,
+                            text: item.title,
+                            font: itemFont,
+                            color: component.colors.foreground,
+                            backgroundColor: component.colors.background,
+                            isSelected: itemId == component.selectedItemId
+                        )),
+                        effectAlignment: .center,
+                        minSize: nil,
+                        action: { [weak itemView] in
+                            if let view = itemView?.title.view {
+                                item.action(view)
+                            }
+                        },
+                        animateScale: false
+                    )),
+                    environment: {},
+                    containerSize: CGSize(width: 200.0, height: 100.0)
+                )
+                innerContentWidth += itemSize.width
+                itemViews[item.id] = (itemView, itemSize, itemTransition)
+                index += 1
+            }
+            
+            let estimatedContentWidth = 2.0 * spacing + innerContentWidth + (CGFloat(component.items.count - 1) * spacing)
+            if estimatedContentWidth > availableSize.width && !allowScroll {
+                spacing = (availableSize.width - innerContentWidth) / CGFloat(component.items.count + 1)
+            }
+            
+            var contentWidth: CGFloat = spacing
+            for item in component.items {
+                guard let (itemView, itemSize, itemTransition) = itemViews[item.id] else {
+                    continue
+                }
+                if contentWidth > spacing {
+                    contentWidth += spacing
+                }
+                let itemFrame = CGRect(origin: CGPoint(x: contentWidth, y: floor((baseHeight - itemSize.height) * 0.5)), size: itemSize)
+                contentWidth = itemFrame.maxX
+                
+                if let itemTitleView = itemView.title.view {
+                    if itemTitleView.superview == nil {
+                        itemTitleView.layer.anchorPoint = CGPoint()
+                        self.addSubview(itemTitleView)
+                    }
+                    itemTransition.setPosition(view: itemTitleView, position: itemFrame.origin)
+                    itemTransition.setBounds(view: itemTitleView, bounds: CGRect(origin: CGPoint(), size: itemFrame.size))
+                }
+            }
+            contentWidth += spacing
+            
+            var removeIds: [AnyHashable] = []
+            for (id, itemView) in self.visibleItems {
+                if !validIds.contains(id) {
+                    removeIds.append(id)
+                    itemView.title.view?.removeFromSuperview()
+                }
+            }
+            for id in removeIds {
+                self.visibleItems.removeValue(forKey: id)
+            }
+            
+            self.contentSize = CGSize(width: contentWidth, height: baseHeight)
+            self.disablesInteractiveTransitionGestureRecognizer = contentWidth > availableSize.width
+            
+            return CGSize(width: min(contentWidth, availableSize.width), height: baseHeight)
+        }
+    }
+    
+    public func makeView() -> View {
+        return View(frame: CGRect())
+    }
+    
+    public func update(view: View, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
+        return view.update(component: self, availableSize: availableSize, state: state, environment: environment, transition: transition)
+    }
+}
+
+extension CGRect {
+    func interpolate(with other: CGRect, fraction: CGFloat) -> CGRect {
+        return CGRect(
+            x: self.origin.x * (1.0 - fraction) + (other.origin.x) * fraction,
+            y: self.origin.y * (1.0 - fraction) + (other.origin.y) * fraction,
+            width: self.size.width * (1.0 - fraction) + (other.size.width) * fraction,
+            height: self.size.height * (1.0 - fraction) + (other.size.height) * fraction
+        )
+    }
+}
+
+private final class ItemComponent: Component {
+    let context: AccountContext?
+    let index: Int
+    let iconName: String?
+    let text: String
+    let font: UIFont
+    let color: UIColor
+    let backgroundColor: UIColor
+    let isSelected: Bool
+    
+    init(
+        context: AccountContext?,
+        index: Int,
+        iconName: String?,
+        text: String,
+        font: UIFont,
+        color: UIColor,
+        backgroundColor: UIColor,
+        isSelected: Bool
+    ) {
+        self.context = context
+        self.index = index
+        self.iconName = iconName
+        self.text = text
+        self.font = font
+        self.color = color
+        self.backgroundColor = backgroundColor
+        self.isSelected = isSelected
+    }
+    
+    static func ==(lhs: ItemComponent, rhs: ItemComponent) -> Bool {
+        if lhs.context !== rhs.context {
+            return false
+        }
+        if lhs.index != rhs.index {
+            return false
+        }
+        if lhs.iconName != rhs.iconName {
+            return false
+        }
+        if lhs.text != rhs.text {
+            return false
+        }
+        if lhs.font != rhs.font {
+            return false
+        }
+        if lhs.color != rhs.color {
+            return false
+        }
+        if lhs.backgroundColor != rhs.backgroundColor {
+            return false
+        }
+        if lhs.isSelected != rhs.isSelected {
+            return false
+        }
+        return true
+    }
+    
+    public final class View: UIView {
+        private var component: ItemComponent?
+        private weak var state: EmptyComponentState?
+        
+        private let background = ComponentView<Empty>()
+        private let title = ComponentView<Empty>()
+        private let icon = ComponentView<Empty>()
+        
+        private var isSelected = false
+        private var iconName: String?
+        
+        private let playOnce = ActionSlot<Void>()
+        
+        override init(frame: CGRect) {
+            super.init(frame: frame)
+        }
+        
+        required init?(coder: NSCoder) {
+            fatalError("init(coder:) has not been implemented")
+        }
+        
+        func update(component: ItemComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
+            let previousComponent = self.component
+            self.component = component
+            self.state = state
+            
+            var animateTitleInDirection: CGFloat?
+            if let previousComponent, previousComponent.text != component.text, !transition.animation.isImmediate, let titleView = self.title.view, let snapshotView = titleView.snapshotView(afterScreenUpdates: false) {
+                snapshotView.frame = titleView.frame
+                self.addSubview(snapshotView)
+                
+                var direction: CGFloat = 1.0
+                if previousComponent.index < component.index {
+                    direction = -1.0
+                }
+                
+                snapshotView.layer.animatePosition(from: .zero, to: CGPoint(x: 0.0, y: 6.0 * direction), duration: 0.2, removeOnCompletion: false, additive: true)
+                snapshotView.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.2, removeOnCompletion: false, completion: { _ in
+                    snapshotView.removeFromSuperview()
+                })
+                
+                animateTitleInDirection = direction
+            }
+            
+            let attributedTitle = NSAttributedString(string: component.text, font: component.font, textColor: component.color)
+            let titleSize = self.title.update(
+                transition: .immediate,
+                component: AnyComponent(MultilineTextComponent(
+                    text: .plain(attributedTitle)
+                )),
+                environment: {},
+                containerSize: availableSize
+            )
+            
+            let animationName = component.iconName ?? (component.isSelected ? "GiftFilterMenuOpen" : "GiftFilterMenuClose")
+            let animationSize = component.iconName != nil ? CGSize(width: 22.0, height: 22.0) : CGSize(width: 10.0, height: 22.0)
+            
+            let iconSize = self.icon.update(
+                transition: transition,
+                component: AnyComponent(LottieComponent(
+                    content: LottieComponent.AppBundleContent(name: animationName),
+                    color: component.color,
+                    playOnce: self.playOnce
+                )),
+                environment: {},
+                containerSize: CGSize(width: 22.0, height: 22.0)
+            )
+        
+            var playAnimation = false
+            if self.isSelected != component.isSelected || self.iconName != component.iconName {
+                if let iconName = component.iconName {
+                    if component.isSelected {
+                        playAnimation = true
+                    } else if self.iconName != iconName {
+                        playAnimation = true
+                    }
+                    self.iconName = iconName
+                } else {
+                    playAnimation = true
+                }
+                self.isSelected = component.isSelected
+            }
+            if playAnimation {
+                self.playOnce.invoke(Void())
+            }
+            
+            let padding: CGFloat = 12.0
+            var leftPadding = padding
+            if let _ = component.iconName {
+                leftPadding -= 4.0
+            }
+            let spacing: CGFloat = 4.0
+            let totalWidth = titleSize.width + animationSize.width + spacing
+            let size = CGSize(width: totalWidth + leftPadding + padding, height: 28.0)
+            
+            let backgroundSize = self.background.update(
+                transition: transition,
+                component: AnyComponent(RoundedRectangle(
+                    color: component.backgroundColor,
+                    cornerRadius: 14.0
+                )),
+                environment: {},
+                containerSize: size
+            )
+            
+            if let backgroundView = self.background.view {
+                if backgroundView.superview == nil {
+                    self.addSubview(backgroundView)
+                }
+                transition.setPosition(view: backgroundView, position: CGPoint(x: size.width / 2.0, y: size.height / 2.0))
+                transition.setBounds(view: backgroundView, bounds: CGRect(origin: CGPoint(), size: backgroundSize))
+            }
+            
+            if let titleView = self.title.view {
+                if titleView.superview == nil {
+                    self.addSubview(titleView)
+                }
+                let titlePosition: CGPoint
+                if let _ = component.iconName {
+                    titlePosition = CGPoint(x: size.width - padding - titleSize.width / 2.0, y: size.height / 2.0)
+                } else {
+                    titlePosition = CGPoint(x: padding + titleSize.width / 2.0, y: size.height / 2.0)
+                }
+                if let animateTitleInDirection {
+                    titleView.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
+                    titleView.center = CGPoint(x: titlePosition.x, y: titlePosition.y - 6.0 * animateTitleInDirection)
+                }
+                transition.setPosition(view: titleView, position: titlePosition)
+                titleView.bounds = CGRect(origin: CGPoint(), size: titleSize)
+            }
+            
+            if let iconView = self.icon.view {
+                if iconView.superview == nil {
+                    self.addSubview(iconView)
+                }
+                let iconPosition: CGPoint
+                if let _ = component.iconName {
+                    iconPosition = CGPoint(x: leftPadding + iconSize.width / 2.0, y: size.height / 2.0)
+                } else {
+                    iconPosition = CGPoint(x: size.width - padding - animationSize.width / 2.0, y: size.height / 2.0)
+                }
+                transition.setPosition(view: iconView, position: iconPosition)
+                transition.setBounds(view: iconView, bounds: CGRect(origin: CGPoint(), size: iconSize))
+            }
+            
+            return size
+        }
+    }
+    
+    public func makeView() -> View {
+        return View(frame: CGRect())
+    }
+    
+    public func update(view: View, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
+        return view.update(component: self, availableSize: availableSize, state: state, environment: environment, transition: transition)
+    }
+}

submodules/TelegramUI/Components/Gifts/GiftStoreScreen/Sources/GiftAttributeListContextItem.swift

@@ -0,0 +1,601 @@
+import Foundation
+import UIKit
+import AsyncDisplayKit
+import Display
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import AccountContext
+import TelegramPresentationData
+import ContextUI
+
+final class GiftAttributeListContextItem: ContextMenuCustomItem {
+    let context: AccountContext
+    let attributes: [StarGift.UniqueGift.Attribute]
+    let selectedAttributes: [ResaleGiftsContext.Attribute]
+    let attributeCount: [ResaleGiftsContext.Attribute: Int32]
+    let searchQuery: Signal<String, NoError>
+    let attributeSelected: (ResaleGiftsContext.Attribute, Bool) -> Void
+    let selectAll: () -> Void
+    
+    init(
+        context: AccountContext,
+        attributes: [StarGift.UniqueGift.Attribute],
+        selectedAttributes: [ResaleGiftsContext.Attribute],
+        attributeCount: [ResaleGiftsContext.Attribute: Int32],
+        searchQuery: Signal<String, NoError>,
+        attributeSelected: @escaping (ResaleGiftsContext.Attribute, Bool) -> Void,
+        selectAll: @escaping () -> Void
+    ) {
+        self.context = context
+        self.attributes = attributes
+        self.selectedAttributes = selectedAttributes
+        self.attributeCount = attributeCount
+        self.searchQuery = searchQuery
+        self.attributeSelected = attributeSelected
+        self.selectAll = selectAll
+    }
+    
+    func node(presentationData: PresentationData, getController: @escaping () -> ContextControllerProtocol?, actionSelected: @escaping (ContextMenuActionResult) -> Void) -> ContextMenuCustomNode {
+        return GiftAttributeListContextItemNode(
+            presentationData: presentationData,
+            item: self,
+            getController: getController,
+            actionSelected: actionSelected
+        )
+    }
+}
+
+private func actionForAttribute(attribute: StarGift.UniqueGift.Attribute, presentationData: PresentationData, selectedAttributes: Set<ResaleGiftsContext.Attribute>, searchQuery: String, item: GiftAttributeListContextItem, getController: @escaping () -> ContextControllerProtocol?) -> ContextMenuActionItem? {
+    let searchComponents = searchQuery.lowercased().components(separatedBy: .whitespaces).filter { !$0.isEmpty }
+        
+    switch attribute {
+    case let .model(name, file, _), let .pattern(name, file, _):
+        let attributeId: ResaleGiftsContext.Attribute
+        if case .model = attribute {
+            attributeId = .model(file.fileId.id)
+        } else {
+            attributeId = .pattern(file.fileId.id)
+        }
+        let isSelected = selectedAttributes.isEmpty || selectedAttributes.contains(attributeId)
+        
+        var entities: [MessageTextEntity] = []
+        var entityFiles: [Int64: TelegramMediaFile] = [:]
+        entities = [
+            MessageTextEntity(
+                range: 0..<1,
+                type: .CustomEmoji(stickerPack: nil, fileId: file.fileId.id)
+            )
+        ]
+        entityFiles[file.fileId.id] = file
+                                
+        var title = "#   \(name)"
+        var count = ""
+        
+        if let counter = item.attributeCount[attributeId] {
+            count = "  \(presentationStringsFormattedNumber(counter, presentationData.dateTimeFormat.groupingSeparator))"
+            entities.append(
+                MessageTextEntity(
+                    range: title.count ..< title.count + count.count,
+                    type: .Italic
+                )
+            )
+            title += count
+        }
+      
+        
+        let words = title.components(separatedBy: .whitespacesAndNewlines).filter { !$0.isEmpty }
+        var wordStartIndices: [String.Index] = []
+        var currentIndex = title.startIndex
+        
+        for word in words {
+            while currentIndex < title.endIndex {
+                let range = title.range(of: word, range: currentIndex..<title.endIndex)
+                if let range = range {
+                    wordStartIndices.append(range.lowerBound)
+                    currentIndex = range.upperBound
+                    break
+                }
+                currentIndex = title.index(after: currentIndex)
+            }
+        }
+        
+        for (wordIndex, word) in words.enumerated() {
+            let lowercaseWord = word.lowercased()
+            for component in searchComponents {
+                if lowercaseWord.hasPrefix(component) {
+                    let startIndex = wordStartIndices[wordIndex]
+                    let prefixRange = startIndex..<title.index(startIndex, offsetBy: min(component.count, word.count))
+                    
+                    entities.append(
+                        MessageTextEntity(
+                            range: title.distance(from: title.startIndex, to: prefixRange.lowerBound)..<title.distance(from: title.startIndex, to: prefixRange.upperBound),
+                            type: .Bold
+                        )
+                    )
+                }
+            }
+        }
+             
+        return ContextMenuActionItem(text: title, entities: entities, entityFiles: entityFiles, enableEntityAnimations: false, parseMarkdown: true, icon: { theme in
+            return isSelected ? generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Check"), color: theme.contextMenu.primaryColor) : nil
+        }, action: { _, f in
+            getController()?.dismiss(result: .dismissWithoutContent, completion: nil)
+            
+            item.attributeSelected(attributeId, false)
+        }, longPressAction: { _, f in
+            getController()?.dismiss(result: .dismissWithoutContent, completion: nil)
+            
+            item.attributeSelected(attributeId, true)
+        })
+    case let .backdrop(name, id, innerColor, outerColor, _, _, _):
+        let attributeId: ResaleGiftsContext.Attribute = .backdrop(id)
+        let isSelected = selectedAttributes.isEmpty || selectedAttributes.contains(attributeId)
+        
+        var entities: [MessageTextEntity] = []
+        var title = "   \(name)"
+        var count = ""
+        if let counter = item.attributeCount[attributeId] {
+            count = "  \(presentationStringsFormattedNumber(counter, presentationData.dateTimeFormat.groupingSeparator))"
+            entities.append(
+                MessageTextEntity(range: title.count ..< title.count + count.count, type: .Italic)
+            )
+            title += count
+        }
+        
+        let words = title.components(separatedBy: .whitespacesAndNewlines).filter { !$0.isEmpty }
+        var wordStartIndices: [String.Index] = []
+        var currentIndex = title.startIndex
+        
+        for word in words {
+            while currentIndex < title.endIndex {
+                let range = title.range(of: word, range: currentIndex..<title.endIndex)
+                if let range = range {
+                    wordStartIndices.append(range.lowerBound)
+                    currentIndex = range.upperBound
+                    break
+                }
+                currentIndex = title.index(after: currentIndex)
+            }
+        }
+        
+        for (wordIndex, word) in words.enumerated() {
+            let lowercaseWord = word.lowercased()
+            for component in searchComponents {
+                if lowercaseWord.hasPrefix(component) {
+                    let startIndex = wordStartIndices[wordIndex]
+                    let prefixRange = startIndex..<title.index(startIndex, offsetBy: min(component.count, word.count))
+                    
+                    entities.append(
+                        MessageTextEntity(
+                            range: title.distance(from: title.startIndex, to: prefixRange.lowerBound)..<title.distance(from: title.startIndex, to: prefixRange.upperBound),
+                            type: .Bold
+                        )
+                    )
+                }
+            }
+        }
+        
+        return ContextMenuActionItem(text: title, entities: entities, icon: { theme in
+            return isSelected ? generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Check"), color: theme.contextMenu.primaryColor) : nil
+        }, additionalLeftIcon: { _ in
+            return generateGradientFilledCircleImage(diameter: 24.0, colors: [UIColor(rgb: UInt32(bitPattern: innerColor)).cgColor, UIColor(rgb: UInt32(bitPattern: outerColor)).cgColor])
+        }, action: { _, f in
+            getController()?.dismiss(result: .dismissWithoutContent, completion: nil)
+            
+            item.attributeSelected(attributeId, false)
+        }, longPressAction: { _, f in
+            getController()?.dismiss(result: .dismissWithoutContent, completion: nil)
+            
+            item.attributeSelected(attributeId, true)
+        })
+    default:
+        return nil
+    }
+}
+
+private final class GiftAttributeListContextItemNode: ASDisplayNode, ContextMenuCustomNode, ContextActionNodeProtocol, ASScrollViewDelegate {
+    private let item: GiftAttributeListContextItem
+    private let presentationData: PresentationData
+    private let getController: () -> ContextControllerProtocol?
+    private let actionSelected: (ContextMenuActionResult) -> Void
+    
+    private let scrollNode: ASScrollNode
+    private var actionNodes: [AnyHashable: ContextControllerActionsListActionItemNode] = [:]
+    private var separatorNodes: [AnyHashable: ASDisplayNode] = [:]
+    
+    private var searchDisposable: Disposable?
+    private var searchQuery = ""
+    
+    private var itemHeights: [AnyHashable: CGFloat] = [:]
+    private var totalContentHeight: CGFloat = 0
+    private var itemFrames: [AnyHashable: CGRect] = [:]
+    
+    init(presentationData: PresentationData, item: GiftAttributeListContextItem, getController: @escaping () -> ContextControllerProtocol?, actionSelected: @escaping (ContextMenuActionResult) -> Void) {
+        self.item = item
+        self.presentationData = presentationData.withUpdate(listsFontSize: .regular)
+        self.getController = getController
+        self.actionSelected = actionSelected
+        
+        self.scrollNode = ASScrollNode()
+                                        
+        super.init()
+        
+        self.addSubnode(self.scrollNode)
+        
+        self.searchDisposable = (item.searchQuery
+        |> deliverOnMainQueue).start(next: { [weak self] searchQuery in
+            guard let self, self.searchQuery != searchQuery else {
+                return
+            }
+            self.searchQuery = searchQuery.trimmingCharacters(in: .whitespacesAndNewlines)
+            self.invalidateLayout()
+            self.getController()?.requestLayout(transition: .immediate)
+        })
+    }
+    
+    deinit {
+        self.searchDisposable?.dispose()
+    }
+    
+    override func didLoad() {
+        super.didLoad()
+        
+        self.scrollNode.view.delegate = self.wrappedScrollViewDelegate
+        self.scrollNode.view.alwaysBounceVertical = false
+        self.scrollNode.view.showsHorizontalScrollIndicator = false
+        self.scrollNode.view.scrollIndicatorInsets = UIEdgeInsets(top: 0.0, left: 0.0, bottom: 5.0, right: 0.0)
+    }
+    
+    func scrollViewDidScroll(_ scrollView: UIScrollView) {
+        if let maxWidth = self.maxWidth {
+            self.updateScrolling(maxWidth: maxWidth)
+        }
+    }
+    
+    enum ItemType {
+        case selectAll
+        case attribute(StarGift.UniqueGift.Attribute)
+        case noResults
+        case separator
+    }
+    
+    private func getVisibleItems(in scrollView: UIScrollView, constrainedWidth: CGFloat) -> [(itemId: AnyHashable, itemType: ItemType, frame: CGRect)] {
+        let effectiveAttributes: [StarGift.UniqueGift.Attribute]
+        if self.searchQuery.isEmpty {
+            effectiveAttributes = self.item.attributes
+        } else {
+            effectiveAttributes = filteredAttributes(attributes: self.item.attributes, query: self.searchQuery)
+        }
+        
+        var items: [(itemId: AnyHashable, itemType: ItemType, frame: CGRect)] = []
+        var yOffset: CGFloat = 0
+        
+        let defaultHeight: CGFloat = 42.0
+        if self.searchQuery.isEmpty {
+            let selectAllId = AnyHashable("selectAll")
+            let height = self.itemHeights[selectAllId] ?? defaultHeight
+            let frame = CGRect(x: 0, y: yOffset, width: constrainedWidth, height: height)
+            items.append((selectAllId, .selectAll, frame))
+            yOffset += height
+            
+            let separatorId = AnyHashable("separator_selectAll")
+            let separatorFrame = CGRect(x: 0, y: yOffset, width: constrainedWidth, height: UIScreenPixel)
+            items.append((separatorId, .separator, separatorFrame))
+            yOffset += UIScreenPixel
+        }
+        
+        for (index, attribute) in effectiveAttributes.enumerated() {
+            let attributeId = self.getAttributeId(from: attribute)
+            let height = self.itemHeights[attributeId] ?? defaultHeight
+            let frame = CGRect(x: 0, y: yOffset, width: constrainedWidth, height: height)
+            items.append((attributeId, .attribute(attribute), frame))
+            yOffset += height
+            
+            if index < effectiveAttributes.count - 1 {
+                let separatorId = AnyHashable("separator_\(attributeId)")
+                let separatorFrame = CGRect(x: 0, y: yOffset, width: constrainedWidth, height: UIScreenPixel)
+                items.append((separatorId, .separator, separatorFrame))
+                yOffset += UIScreenPixel
+            }
+        }
+        
+        if !self.searchQuery.isEmpty && effectiveAttributes.isEmpty {
+            let noResultsId = AnyHashable("noResults")
+            let height = self.itemHeights[noResultsId] ?? defaultHeight
+            let frame = CGRect(x: 0, y: yOffset, width: constrainedWidth, height: height)
+            items.append((noResultsId, .noResults, frame))
+            yOffset += height
+        }
+        
+        self.totalContentHeight = yOffset
+
+        for (itemId, _, frame) in items {
+            self.itemFrames[itemId] = frame
+        }
+        
+        let visibleBounds = scrollView.bounds.insetBy(dx: 0.0, dy: -100.0)
+        return items.filter { visibleBounds.intersects($0.frame) }
+    }
+    
+    private func getAttributeId(from attribute: StarGift.UniqueGift.Attribute) -> AnyHashable {
+        switch attribute {
+        case let .model(_, file, _):
+            return AnyHashable("model_\(file.fileId.id)")
+        case let .pattern(_, file, _):
+            return AnyHashable("pattern_\(file.fileId.id)")
+        case let .backdrop(_, id, _, _, _, _, _):
+            return AnyHashable("backdrop_\(id)")
+        default:
+            return AnyHashable("unknown")
+        }
+    }
+    
+    private var maxWidth: CGFloat?
+    private func updateScrolling(maxWidth: CGFloat) {
+        let scrollView = self.scrollNode.view
+        
+        let constrainedWidth = scrollView.bounds.width
+        let visibleItems = self.getVisibleItems(in: scrollView, constrainedWidth: constrainedWidth)
+        
+        var validNodeIds: Set<AnyHashable> = []
+        
+        for (itemId, itemType, frame) in visibleItems {
+            validNodeIds.insert(itemId)
+            
+            switch itemType {
+            case .selectAll:
+                if self.actionNodes[itemId] == nil {
+                    let selectAllAction = ContextMenuActionItem(text: presentationData.strings.Gift_Store_SelectAll, icon: { theme in
+                        return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Select"), color: theme.contextMenu.primaryColor)
+                    }, iconPosition: .left, action: { _, f in
+                        self.getController()?.dismiss(result: .dismissWithoutContent, completion: nil)
+                        self.item.selectAll()
+                    })
+                    
+                    let actionNode = ContextControllerActionsListActionItemNode(
+                        context: self.item.context,
+                        getController: self.getController,
+                        requestDismiss: self.actionSelected,
+                        requestUpdateAction: { _, _ in },
+                        item: selectAllAction
+                    )
+                    self.actionNodes[itemId] = actionNode
+                    self.scrollNode.addSubnode(actionNode)
+                }
+            case let .attribute(attribute):
+                if self.actionNodes[itemId] == nil {
+                    let selectedAttributes = Set(self.item.selectedAttributes)
+                    guard let action = actionForAttribute(
+                        attribute: attribute,
+                        presentationData: self.presentationData,
+                        selectedAttributes: selectedAttributes,
+                        searchQuery: self.searchQuery,
+                        item: self.item,
+                        getController: self.getController
+                    ) else { continue }
+                    
+                    let actionNode = ContextControllerActionsListActionItemNode(
+                        context: self.item.context,
+                        getController: self.getController,
+                        requestDismiss: self.actionSelected,
+                        requestUpdateAction: { _, _ in },
+                        item: action
+                    )
+                    self.actionNodes[itemId] = actionNode
+                    self.scrollNode.addSubnode(actionNode)
+                } else {
+                    let selectedAttributes = Set(self.item.selectedAttributes)
+                    if let action = actionForAttribute(
+                        attribute: attribute,
+                        presentationData: self.presentationData,
+                        selectedAttributes: selectedAttributes,
+                        searchQuery: self.searchQuery,
+                        item: self.item,
+                        getController: self.getController
+                    ) {
+                        self.actionNodes[itemId]?.setItem(item: action)
+                    }
+                }
+            case .noResults:
+                if self.actionNodes[itemId] == nil {
+                    let nopAction: ((ContextControllerProtocol?, @escaping (ContextMenuActionResult) -> Void) -> Void)? = nil
+                    let emptyResultsAction = ContextMenuActionItem(
+                        text: presentationData.strings.Gift_Store_NoResults,
+                        textFont: .small,
+                        icon: { _ in return nil },
+                        action: nopAction
+                    )
+                    let actionNode = ContextControllerActionsListActionItemNode(
+                        context: self.item.context,
+                        getController: self.getController,
+                        requestDismiss: self.actionSelected,
+                        requestUpdateAction: { _, _ in },
+                        item: emptyResultsAction
+                    )
+                    self.actionNodes[itemId] = actionNode
+                    self.scrollNode.addSubnode(actionNode)
+                }
+            case .separator:
+                if self.separatorNodes[itemId] == nil {
+                    let separatorNode = ASDisplayNode()
+                    separatorNode.backgroundColor = presentationData.theme.contextMenu.itemSeparatorColor
+                    self.separatorNodes[itemId] = separatorNode
+                    self.scrollNode.addSubnode(separatorNode)
+                }
+            }
+            
+            if let actionNode = self.actionNodes[itemId] {
+                actionNode.frame = frame
+
+                let (minSize, complete) = actionNode.update(presentationData: self.presentationData, constrainedSize: frame.size)
+                self.itemHeights[itemId] = minSize.height
+                complete(CGSize(width: maxWidth, height: minSize.height), .immediate)
+            } else if let separatorNode = self.separatorNodes[itemId] {
+                separatorNode.frame = frame
+            }
+        }
+        
+        var nodesToRemove: [AnyHashable] = []
+        for (nodeId, node) in self.actionNodes {
+            if !validNodeIds.contains(nodeId) {
+                nodesToRemove.append(nodeId)
+                node.removeFromSupernode()
+            }
+        }
+        for nodeId in nodesToRemove {
+            self.actionNodes.removeValue(forKey: nodeId)
+        }
+        
+        var separatorsToRemove: [AnyHashable] = []
+        for (separatorId, separatorNode) in self.separatorNodes {
+            if !validNodeIds.contains(separatorId) {
+                separatorsToRemove.append(separatorId)
+                separatorNode.removeFromSupernode()
+            }
+        }
+        for separatorId in separatorsToRemove {
+            self.separatorNodes.removeValue(forKey: separatorId)
+        }
+    }
+    
+    private func invalidateLayout() {
+        self.itemHeights.removeAll()
+        self.itemFrames.removeAll()
+        self.totalContentHeight = 0.0
+    }
+
+    func updateLayout(constrainedWidth: CGFloat, constrainedHeight: CGFloat) -> (CGSize, (CGSize, ContainedViewLayoutTransition) -> Void) {
+        let minActionsWidth: CGFloat = 250.0
+        let maxActionsWidth: CGFloat = 300.0
+        let constrainedWidth = min(constrainedWidth, maxActionsWidth)
+        let maxWidth = max(constrainedWidth, minActionsWidth)
+        
+        let maxHeight: CGFloat = min(360.0, constrainedHeight - 108.0)
+        
+        if self.totalContentHeight == 0 {
+            let _ = self.getVisibleItems(in: UIScrollView(), constrainedWidth: constrainedWidth)
+        }
+        
+        return (CGSize(width: maxWidth, height: min(maxHeight, self.totalContentHeight)), { size, transition in
+            self.maxWidth = maxWidth
+            
+            transition.updateFrame(node: self.scrollNode, frame: CGRect(origin: CGPoint(), size: size))
+            self.scrollNode.view.contentSize = CGSize(width: size.width, height: self.totalContentHeight)
+
+            self.updateScrolling(maxWidth: maxWidth)
+        })
+    }
+    
+    func updateTheme(presentationData: PresentationData) {
+
+    }
+    
+    var isActionEnabled: Bool {
+        return true
+    }
+    
+    func performAction() {
+    }
+    
+    func setIsHighlighted(_ value: Bool) {
+    }
+    
+    func canBeHighlighted() -> Bool {
+        return self.isActionEnabled
+    }
+    
+    func updateIsHighlighted(isHighlighted: Bool) {
+        self.setIsHighlighted(isHighlighted)
+    }
+    
+    func actionNode(at point: CGPoint) -> ContextActionNodeProtocol {
+        return self
+    }
+    
+    func scrollViewWillBeginDragging(_ scrollView: UIScrollView) {
+        for (_, actionNode) in self.actionNodes {
+            actionNode.updateIsHighlighted(isHighlighted: false)
+        }
+    }
+}
+
+
+private func stringTokens(_ string: String) -> [ValueBoxKey] {
+    let nsString = string.folding(options: .diacriticInsensitive, locale: .current).lowercased() as NSString
+    
+    let flag = UInt(kCFStringTokenizerUnitWord)
+    let tokenizer = CFStringTokenizerCreate(kCFAllocatorDefault, nsString, CFRangeMake(0, nsString.length), flag, CFLocaleCopyCurrent())
+    var tokenType = CFStringTokenizerAdvanceToNextToken(tokenizer)
+    var tokens: [ValueBoxKey] = []
+    
+    var addedTokens = Set<ValueBoxKey>()
+    while tokenType != [] {
+        let currentTokenRange = CFStringTokenizerGetCurrentTokenRange(tokenizer)
+        
+        if currentTokenRange.location >= 0 && currentTokenRange.length != 0 {
+            let token = ValueBoxKey(length: currentTokenRange.length * 2)
+            nsString.getCharacters(token.memory.assumingMemoryBound(to: unichar.self), range: NSMakeRange(currentTokenRange.location, currentTokenRange.length))
+            if !addedTokens.contains(token) {
+                tokens.append(token)
+                addedTokens.insert(token)
+            }
+        }
+        tokenType = CFStringTokenizerAdvanceToNextToken(tokenizer)
+    }
+    
+    return tokens
+}
+
+private func matchStringTokens(_ tokens: [ValueBoxKey], with other: [ValueBoxKey]) -> Bool {
+    if other.isEmpty {
+        return false
+    } else if other.count == 1 {
+        let otherToken = other[0]
+        for token in tokens {
+            if otherToken.isPrefix(to: token) {
+                return true
+            }
+        }
+    } else {
+        for otherToken in other {
+            var found = false
+            for token in tokens {
+                if otherToken.isPrefix(to: token) {
+                    found = true
+                    break
+                }
+            }
+            if !found {
+                return false
+            }
+        }
+        return true
+    }
+    return false
+}
+
+private func filteredAttributes(attributes: [StarGift.UniqueGift.Attribute], query: String) -> [StarGift.UniqueGift.Attribute] {
+    let queryTokens = stringTokens(query.lowercased())
+    
+    var result: [StarGift.UniqueGift.Attribute] = []
+    for attribute in attributes {
+        let string: String
+        switch attribute {
+        case let .model(name, _, _):
+            string = name
+        case let .pattern(name, _, _):
+            string = name
+        case let .backdrop(name, _, _, _, _, _, _):
+            string = name
+        default:
+            continue
+        }
+        let tokens = stringTokens(string)
+        if matchStringTokens(tokens, with: queryTokens) {
+            result.append(attribute)
+        }
+    }
+
+    return result
+}

submodules/TelegramUI/Components/Gifts/GiftStoreScreen/Sources/SearchContextItem.swift

@@ -0,0 +1,223 @@
+import Foundation
+import UIKit
+import AsyncDisplayKit
+import Display
+import ComponentFlow
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import AccountContext
+import TelegramPresentationData
+import ContextUI
+import TextFieldComponent
+import MultilineTextComponent
+import BundleIconComponent
+
+final class SearchContextItem: ContextMenuCustomItem {
+    let context: AccountContext
+    let placeholder: String
+    let value: String
+    let valueChanged: (String) -> Void
+    
+    init(
+        context: AccountContext,
+        placeholder: String,
+        value: String,
+        valueChanged: @escaping (String) -> Void
+    ) {
+        self.context = context
+        self.placeholder = placeholder
+        self.value = value
+        self.valueChanged = valueChanged
+    }
+    
+    func node(presentationData: PresentationData, getController: @escaping () -> ContextControllerProtocol?, actionSelected: @escaping (ContextMenuActionResult) -> Void) -> ContextMenuCustomNode {
+        return SearchContextItemNode(
+            presentationData: presentationData,
+            item: self,
+            getController: getController,
+            actionSelected: actionSelected
+        )
+    }
+}
+
+private final class SearchContextItemNode: ASDisplayNode, ContextMenuCustomNode, ContextActionNodeProtocol, ASScrollViewDelegate {
+    private let item: SearchContextItem
+    private let presentationData: PresentationData
+    private let getController: () -> ContextControllerProtocol?
+    private let actionSelected: (ContextMenuActionResult) -> Void
+    
+    private let state = EmptyComponentState()
+    private let icon = ComponentView<Empty>()
+    private let inputField = ComponentView<Empty>()
+    private let inputFieldExternalState = TextFieldComponent.ExternalState()
+    private let inputPlaceholderView = ComponentView<Empty>()
+    private let inputClear = ComponentView<Empty>()
+    private var inputText = ""
+    
+    private var validLayout: CGSize?
+    
+    init(presentationData: PresentationData, item: SearchContextItem, getController: @escaping () -> ContextControllerProtocol?, actionSelected: @escaping (ContextMenuActionResult) -> Void) {
+        self.item = item
+        self.presentationData = presentationData
+        self.getController = getController
+        self.actionSelected = actionSelected
+        
+        super.init()
+        
+        self.state._updated = { [weak self] transition, _ in
+            guard let self, let size = self.validLayout else {
+                return
+            }
+            self.internalUpdateLayout(size: size, transition: transition)
+        }
+    }
+    
+    func internalUpdateLayout(size: CGSize, transition: ComponentTransition) {
+        let iconSize = self.icon.update(
+            transition: .immediate,
+            component: AnyComponent(BundleIconComponent(name: "Chat/Context Menu/Search", tintColor: self.presentationData.theme.contextMenu.primaryColor)),
+            environment: {},
+            containerSize: size
+        )
+        let iconFrame = CGRect(origin: CGPoint(x: 17.0, y: floorToScreenPixels((size.height - iconSize.height) / 2.0)), size: iconSize)
+        if let iconView = self.icon.view {
+            if iconView.superview == nil {
+                self.view.addSubview(iconView)
+            }
+            transition.setFrame(view: iconView, frame: iconFrame)
+        }
+        
+        let inputInset: CGFloat = 42.0
+        
+        self.inputField.parentState = self.state
+        let inputFieldSize = self.inputField.update(
+            transition: .immediate,
+            component: AnyComponent(TextFieldComponent(
+                context: self.item.context,
+                theme: self.presentationData.theme,
+                strings: self.presentationData.strings,
+                externalState: self.inputFieldExternalState,
+                fontSize: self.presentationData.listsFontSize.baseDisplaySize,
+                textColor: self.presentationData.theme.contextMenu.primaryColor,
+                accentColor: self.presentationData.theme.contextMenu.primaryColor,
+                insets: UIEdgeInsets(top: 8.0, left: 2.0, bottom: 8.0, right: 2.0),
+                hideKeyboard: false,
+                customInputView: nil,
+                resetText: nil,
+                isOneLineWhenUnfocused: false,
+                emptyLineHandling: .notAllowed,
+                formatMenuAvailability: .none,
+                returnKeyType: .search,
+                lockedFormatAction: {
+                },
+                present: { _ in
+                },
+                paste: { _ in
+                },
+                returnKeyAction: nil,
+                backspaceKeyAction: nil
+            )),
+            environment: {},
+            containerSize: CGSize(width: size.width - inputInset - 40.0, height: size.height)
+        )
+        let inputFieldFrame = CGRect(origin: CGPoint(x: inputInset, y: floorToScreenPixels((size.height - inputFieldSize.height) / 2.0)), size: inputFieldSize)
+        if let inputFieldView = self.inputField.view as? TextFieldComponent.View {
+            if inputFieldView.superview == nil {
+                self.view.addSubview(inputFieldView)
+            }
+            transition.setFrame(view: inputFieldView, frame: inputFieldFrame)
+        }
+                    
+        if self.inputText != self.inputFieldExternalState.text.string {
+            self.inputText = self.inputFieldExternalState.text.string
+            self.item.valueChanged(self.inputText)
+        }
+        
+        let inputPlaceholderSize = self.inputPlaceholderView.update(
+            transition: .immediate,
+            component: AnyComponent(
+                MultilineTextComponent(text: .plain(NSAttributedString(
+                    string: self.item.placeholder,
+                    font: Font.regular(self.presentationData.listsFontSize.baseDisplaySize),
+                    textColor: self.presentationData.theme.contextMenu.secondaryColor
+                )))
+            ),
+            environment: {},
+            containerSize: size
+        )
+        let inputPlaceholderFrame = CGRect(origin: CGPoint(x: inputInset + 10.0, y: floorToScreenPixels(inputFieldFrame.midY - inputPlaceholderSize.height / 2.0)), size: inputPlaceholderSize)
+        if let inputPlaceholderView = self.inputPlaceholderView.view {
+            if inputPlaceholderView.superview == nil {
+                inputPlaceholderView.isUserInteractionEnabled = false
+                self.view.addSubview(inputPlaceholderView)
+            }
+            inputPlaceholderView.frame = inputPlaceholderFrame
+            inputPlaceholderView.isHidden = self.inputFieldExternalState.hasText
+        }
+        
+        let inputClearSize = self.inputClear.update(
+            transition: .immediate,
+            component: AnyComponent(
+                Button(
+                    content: AnyComponent(
+                        BundleIconComponent(name: "Components/Search Bar/Clear", tintColor: self.presentationData.theme.contextMenu.secondaryColor, maxSize: CGSize(width: 24.0, height: 24.0))
+                    ),
+                    action: { [weak self] in
+                        guard let self else {
+                            return
+                        }
+                        if let inputFieldView = self.inputField.view as? TextFieldComponent.View {
+                            inputFieldView.updateText(NSAttributedString(), selectionRange: 0..<0)
+                        }
+                    }
+                )
+            ),
+            environment: {},
+            containerSize: CGSize(width: 30.0, height: 30.0)
+        )
+        let inputClearFrame = CGRect(origin: CGPoint(x: size.width - inputClearSize.width - 16.0, y: floorToScreenPixels(inputFieldFrame.midY - inputClearSize.height / 2.0)), size: inputClearSize)
+        if let inputClearView = self.inputClear.view {
+            if inputClearView.superview == nil {
+                self.view.addSubview(inputClearView)
+            }
+            inputClearView.frame = inputClearFrame
+            inputClearView.isHidden = !self.inputFieldExternalState.hasText
+        }
+    }
+    
+    func updateLayout(constrainedWidth: CGFloat, constrainedHeight: CGFloat) -> (CGSize, (CGSize, ContainedViewLayoutTransition) -> Void) {
+        let maxWidth: CGFloat = 220.0
+        let height: CGFloat = 42.0
+        
+        return (CGSize(width: maxWidth, height: height), { size, transition in
+            self.validLayout = size
+            self.internalUpdateLayout(size: size, transition: ComponentTransition(transition))
+        })
+    }
+    
+    func updateTheme(presentationData: PresentationData) {
+
+    }
+    
+    var isActionEnabled: Bool {
+        return true
+    }
+    
+    func performAction() {
+    }
+    
+    func setIsHighlighted(_ value: Bool) {
+    }
+    
+    func canBeHighlighted() -> Bool {
+        return false
+    }
+    
+    func updateIsHighlighted(isHighlighted: Bool) {
+    }
+    
+    func actionNode(at point: CGPoint) -> ContextActionNodeProtocol {
+        return self
+    }
+}