Merge commit '7621e2f8dec938cf48181c8b10afc9b01f444e68' into beta

submodules/TelegramUI/Components/ShareWithPeersScreen/Sources/CategoryListItemComponent.swift

@@ -0,0 +1,330 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import ComponentFlow
+import SwiftSignalKit
+import AccountContext
+import TelegramCore
+import MultilineTextComponent
+import AvatarNode
+import TelegramPresentationData
+import CheckNode
+import BundleIconComponent
+
+final class CategoryListItemComponent: Component {
+    enum SelectionState: Equatable {
+        case none
+        case editing(isSelected: Bool, isTinted: Bool)
+    }
+    
+    let context: AccountContext
+    let theme: PresentationTheme
+    let title: String
+    let color: ShareWithPeersScreenComponent.CategoryColor
+    let iconName: String?
+    let subtitle: String?
+    let selectionState: SelectionState
+    let hasNext: Bool
+    let action: () -> Void
+    let secondaryAction: () -> Void
+    
+    init(
+        context: AccountContext,
+        theme: PresentationTheme,
+        title: String,
+        color: ShareWithPeersScreenComponent.CategoryColor,
+        iconName: String?,
+        subtitle: String?,
+        selectionState: SelectionState,
+        hasNext: Bool,
+        action: @escaping () -> Void,
+        secondaryAction: @escaping () -> Void
+    ) {
+        self.context = context
+        self.theme = theme
+        self.title = title
+        self.color = color
+        self.iconName = iconName
+        self.subtitle = subtitle
+        self.selectionState = selectionState
+        self.hasNext = hasNext
+        self.action = action
+        self.secondaryAction = secondaryAction
+    }
+    
+    static func ==(lhs: CategoryListItemComponent, rhs: CategoryListItemComponent) -> Bool {
+        if lhs.context !== rhs.context {
+            return false
+        }
+        if lhs.theme !== rhs.theme {
+            return false
+        }
+        if lhs.title != rhs.title {
+            return false
+        }
+        if lhs.color != rhs.color {
+            return false
+        }
+        if lhs.iconName != rhs.iconName {
+            return false
+        }
+        if lhs.subtitle != rhs.subtitle {
+            return false
+        }
+        if lhs.selectionState != rhs.selectionState {
+            return false
+        }
+        if lhs.hasNext != rhs.hasNext {
+            return false
+        }
+        return true
+    }
+    
+    final class View: UIView {
+        private let containerButton: HighlightTrackingButton
+        
+        private let title = ComponentView<Empty>()
+        private let label = ComponentView<Empty>()
+        private let labelArrow = ComponentView<Empty>()
+        private let separatorLayer: SimpleLayer
+        private let iconView: UIImageView
+        
+        private var checkLayer: CheckLayer?
+        
+        private var component: CategoryListItemComponent?
+        private weak var state: EmptyComponentState?
+        
+        override init(frame: CGRect) {
+            self.separatorLayer = SimpleLayer()
+            
+            self.containerButton = HighlightTrackingButton()
+            
+            self.iconView = UIImageView()
+            
+            super.init(frame: frame)
+            
+            self.layer.addSublayer(self.separatorLayer)
+            self.addSubview(self.containerButton)
+            self.containerButton.addSubview(self.iconView)
+            
+            self.containerButton.addTarget(self, action: #selector(self.pressed), for: .touchUpInside)
+        }
+        
+        required init?(coder: NSCoder) {
+            fatalError("init(coder:) has not been implemented")
+        }
+        
+        @objc private func pressed() {
+            guard let component = self.component else {
+                return
+            }
+            if case .editing(true, _) = component.selectionState {
+                component.secondaryAction()
+            } else {
+                component.action()
+            }
+        }
+        
+        func update(component: CategoryListItemComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
+            let themeUpdated = self.component?.theme !== component.theme
+            
+            var hasSelectionUpdated = false
+            if let previousComponent = self.component {
+                switch previousComponent.selectionState {
+                case .none:
+                    if case .none = component.selectionState {
+                    } else {
+                        hasSelectionUpdated = true
+                    }
+                case .editing:
+                    if case .editing = component.selectionState {
+                    } else {
+                        hasSelectionUpdated = true
+                    }
+                }
+            }
+            
+            if (self.component?.iconName != component.iconName || self.component?.color != component.color), let iconName = component.iconName {
+                let colors: [UIColor]
+                var iconScale: CGFloat = 1.0
+                switch component.color {
+                case .blue:
+                    colors = [UIColor(rgb: 0x4faaff), UIColor(rgb: 0x017aff)]
+                case .yellow:
+                    colors = [UIColor(rgb: 0xffb643), UIColor(rgb: 0xf69a36)]
+                case .green:
+                    colors = [UIColor(rgb: 0x87d93a), UIColor(rgb: 0x31b73b)]
+                case .purple:
+                    colors = [UIColor(rgb: 0xc36eff), UIColor(rgb: 0x8c61fa)]
+                case .red:
+                    colors = [UIColor(rgb: 0xc36eff), UIColor(rgb: 0x8c61fa)]
+                case .violet:
+                    colors = [UIColor(rgb: 0xc36eff), UIColor(rgb: 0x8c61fa)]
+                }
+                
+                iconScale = 1.0
+                
+                self.iconView.image = generateAvatarImage(size: CGSize(width: 40.0, height: 40.0), icon: generateTintedImage(image: UIImage(bundleImageName: iconName), color: .white), iconScale: iconScale, cornerRadius: 20.0, color: .blue, customColors: colors.reversed())
+            }
+            
+            self.component = component
+            self.state = state
+            
+            let contextInset: CGFloat = 0.0
+            
+            let height: CGFloat = 64.0
+            let verticalInset: CGFloat = 0.0
+            var leftInset: CGFloat = 62.0
+            let rightInset: CGFloat = contextInset * 2.0 + 8.0
+            var avatarLeftInset: CGFloat = 10.0
+            
+            if case let .editing(isSelected, isTinted) = component.selectionState {
+                leftInset += 44.0
+                avatarLeftInset += 44.0
+                let checkSize: CGFloat = 22.0
+                
+                let checkLayer: CheckLayer
+                if let current = self.checkLayer {
+                    checkLayer = current
+                    if themeUpdated {
+                        var theme = CheckNodeTheme(theme: component.theme, style: .plain)
+                        if isTinted {
+                            theme.backgroundColor = theme.backgroundColor.mixedWith(component.theme.list.itemBlocksBackgroundColor, alpha: 0.5)
+                        }
+                        checkLayer.theme = theme
+                    }
+                    checkLayer.setSelected(isSelected, animated: !transition.animation.isImmediate)
+                } else {
+                    var theme = CheckNodeTheme(theme: component.theme, style: .plain)
+                    if isTinted {
+                        theme.backgroundColor = theme.backgroundColor.mixedWith(component.theme.list.itemBlocksBackgroundColor, alpha: 0.5)
+                    }
+                    checkLayer = CheckLayer(theme: theme)
+                    self.checkLayer = checkLayer
+                    self.containerButton.layer.addSublayer(checkLayer)
+                    checkLayer.frame = CGRect(origin: CGPoint(x: -checkSize, y: floor((height - verticalInset * 2.0 - checkSize) / 2.0)), size: CGSize(width: checkSize, height: checkSize))
+                    checkLayer.setSelected(isSelected, animated: false)
+                    checkLayer.setNeedsDisplay()
+                }
+                transition.setFrame(layer: checkLayer, frame: CGRect(origin: CGPoint(x: floor((54.0 - checkSize) * 0.5), y: floor((height - verticalInset * 2.0 - checkSize) / 2.0)), size: CGSize(width: checkSize, height: checkSize)))
+            } else {
+                if let checkLayer = self.checkLayer {
+                    self.checkLayer = nil
+                    transition.setPosition(layer: checkLayer, position: CGPoint(x: -checkLayer.bounds.width * 0.5, y: checkLayer.position.y), completion: { [weak checkLayer] _ in
+                        checkLayer?.removeFromSuperlayer()
+                    })
+                }
+            }
+            
+            let avatarSize: CGFloat = 40.0
+            
+            let avatarFrame = CGRect(origin: CGPoint(x: avatarLeftInset, y: floor((height - verticalInset * 2.0 - avatarSize) / 2.0)), size: CGSize(width: avatarSize, height: avatarSize))
+            
+            if themeUpdated {
+            }
+            
+            transition.setFrame(view: self.iconView, frame: avatarFrame)
+            
+            let labelData: (String, Bool, Bool)
+            if let subtitle = component.subtitle {
+                labelData = (subtitle, true, true)
+            } else {
+                labelData = ("", false, false)
+            }
+            
+            let labelSize = self.label.update(
+                transition: .immediate,
+                component: AnyComponent(MultilineTextComponent(
+                    text: .plain(NSAttributedString(string: labelData.0, font: Font.regular(15.0), textColor: labelData.1 ? component.theme.list.itemAccentColor : component.theme.list.itemSecondaryTextColor))
+                )),
+                environment: {},
+                containerSize: CGSize(width: availableSize.width - leftInset - rightInset - 14.0, height: 100.0)
+            )
+            
+            let labelArrowSize = self.labelArrow.update(
+                transition: .immediate,
+                component: AnyComponent(BundleIconComponent(name: "Contact List/SubtitleArrow", tintColor: component.theme.list.itemAccentColor)),
+                environment: {},
+                containerSize: CGSize(width: availableSize.width - leftInset - rightInset, height: 100.0)
+            )
+            
+            let previousTitleFrame = self.title.view?.frame
+            var previousTitleContents: UIView?
+            if hasSelectionUpdated && !"".isEmpty {
+                previousTitleContents = self.title.view?.snapshotView(afterScreenUpdates: false)
+            }
+            
+            let titleSize = self.title.update(
+                transition: .immediate,
+                component: AnyComponent(MultilineTextComponent(
+                    text: .plain(NSAttributedString(string: component.title, font: Font.semibold(17.0), textColor: component.theme.list.itemPrimaryTextColor))
+                )),
+                environment: {},
+                containerSize: CGSize(width: availableSize.width - leftInset - rightInset, height: 100.0)
+            )
+            
+            let titleSpacing: CGFloat = 3.0
+            var centralContentHeight: CGFloat = titleSize.height
+            if !labelData.0.isEmpty {
+                centralContentHeight += titleSpacing + labelSize.height
+            }
+            
+            let titleFrame = CGRect(origin: CGPoint(x: leftInset, y: floor((height - verticalInset * 2.0 - centralContentHeight) / 2.0)), size: titleSize)
+            if let titleView = self.title.view {
+                if titleView.superview == nil {
+                    titleView.isUserInteractionEnabled = false
+                    self.containerButton.addSubview(titleView)
+                }
+                titleView.frame = titleFrame
+                if let previousTitleFrame, previousTitleFrame.origin.x != titleFrame.origin.x {
+                    transition.animatePosition(view: titleView, from: CGPoint(x: previousTitleFrame.origin.x - titleFrame.origin.x, y: 0.0), to: CGPoint(), additive: true)
+                }
+                
+                if let previousTitleFrame, let previousTitleContents, previousTitleFrame.size != titleSize {
+                    previousTitleContents.frame = CGRect(origin: previousTitleFrame.origin, size: previousTitleFrame.size)
+                    self.addSubview(previousTitleContents)
+                    
+                    transition.setFrame(view: previousTitleContents, frame: CGRect(origin: titleFrame.origin, size: previousTitleFrame.size))
+                    transition.setAlpha(view: previousTitleContents, alpha: 0.0, completion: { [weak previousTitleContents] _ in
+                        previousTitleContents?.removeFromSuperview()
+                    })
+                    transition.animateAlpha(view: titleView, from: 0.0, to: 1.0)
+                }
+            }
+            if let labelView = self.label.view {
+                if labelView.superview == nil {
+                    labelView.isUserInteractionEnabled = false
+                    self.containerButton.addSubview(labelView)
+                }
+                transition.setFrame(view: labelView, frame: CGRect(origin: CGPoint(x: titleFrame.minX, y: titleFrame.maxY + titleSpacing), size: labelSize))
+            }
+            if let labelArrowView = self.labelArrow.view, !labelData.0.isEmpty {
+                if labelArrowView.superview == nil {
+                    labelArrowView.isUserInteractionEnabled = false
+                    self.containerButton.addSubview(labelArrowView)
+                }
+                transition.setFrame(view: labelArrowView, frame: CGRect(origin: CGPoint(x: titleFrame.minX + labelSize.width + 5.0, y: titleFrame.maxY + titleSpacing + floorToScreenPixels(labelSize.height / 2.0 - labelArrowSize.height / 2.0) + 1.0 ), size: labelArrowSize))
+            }
+            
+            if themeUpdated {
+                self.separatorLayer.backgroundColor = component.theme.list.itemPlainSeparatorColor.cgColor
+            }
+            transition.setFrame(layer: self.separatorLayer, frame: CGRect(origin: CGPoint(x: leftInset, y: height), size: CGSize(width: availableSize.width - leftInset, height: UIScreenPixel)))
+            self.separatorLayer.isHidden = !component.hasNext
+            
+            let containerFrame = CGRect(origin: CGPoint(x: contextInset, y: verticalInset), size: CGSize(width: availableSize.width - contextInset * 2.0, height: height - verticalInset * 2.0))
+            transition.setFrame(view: self.containerButton, frame: containerFrame)
+            
+            return CGSize(width: availableSize.width, height: height)
+        }
+    }
+    
+    func makeView() -> View {
+        return View(frame: CGRect())
+    }
+    
+    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/ShareWithPeersScreen/Sources/CountryListItemComponent.swift

@@ -0,0 +1,225 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import ComponentFlow
+import SwiftSignalKit
+import AccountContext
+import TelegramCore
+import MultilineTextComponent
+import AvatarNode
+import TelegramPresentationData
+import CheckNode
+import BundleIconComponent
+
+final class CountryListItemComponent: Component {
+    enum SelectionState: Equatable {
+        case none
+        case editing(isSelected: Bool, isTinted: Bool)
+    }
+    
+    let context: AccountContext
+    let theme: PresentationTheme
+    let title: String
+    let selectionState: SelectionState
+    let hasNext: Bool
+    let action: () -> Void
+    
+    init(
+        context: AccountContext,
+        theme: PresentationTheme,
+        title: String,
+        selectionState: SelectionState,
+        hasNext: Bool,
+        action: @escaping () -> Void
+    ) {
+        self.context = context
+        self.theme = theme
+        self.title = title
+        self.selectionState = selectionState
+        self.hasNext = hasNext
+        self.action = action
+    }
+    
+    static func ==(lhs: CountryListItemComponent, rhs: CountryListItemComponent) -> Bool {
+        if lhs.context !== rhs.context {
+            return false
+        }
+        if lhs.theme !== rhs.theme {
+            return false
+        }
+        if lhs.title != rhs.title {
+            return false
+        }
+        if lhs.selectionState != rhs.selectionState {
+            return false
+        }
+        if lhs.hasNext != rhs.hasNext {
+            return false
+        }
+        return true
+    }
+    
+    final class View: UIView {
+        private let containerButton: HighlightTrackingButton
+        
+        private let title = ComponentView<Empty>()
+        private let separatorLayer: SimpleLayer
+        
+        private var checkLayer: CheckLayer?
+        
+        private var component: CountryListItemComponent?
+        private weak var state: EmptyComponentState?
+        
+        override init(frame: CGRect) {
+            self.separatorLayer = SimpleLayer()
+            
+            self.containerButton = HighlightTrackingButton()
+                        
+            super.init(frame: frame)
+            
+            self.layer.addSublayer(self.separatorLayer)
+            self.addSubview(self.containerButton)
+            
+            self.containerButton.addTarget(self, action: #selector(self.pressed), for: .touchUpInside)
+        }
+        
+        required init?(coder: NSCoder) {
+            fatalError("init(coder:) has not been implemented")
+        }
+        
+        @objc private func pressed() {
+            guard let component = self.component else {
+                return
+            }
+            component.action()
+        }
+        
+        func update(component: CountryListItemComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
+            let themeUpdated = self.component?.theme !== component.theme
+            
+            var hasSelectionUpdated = false
+            if let previousComponent = self.component {
+                switch previousComponent.selectionState {
+                case .none:
+                    if case .none = component.selectionState {
+                    } else {
+                        hasSelectionUpdated = true
+                    }
+                case .editing:
+                    if case .editing = component.selectionState {
+                    } else {
+                        hasSelectionUpdated = true
+                    }
+                }
+            }
+            
+            self.component = component
+            self.state = state
+            
+            let contextInset: CGFloat = 0.0
+            
+            let height: CGFloat = 44.0
+            let verticalInset: CGFloat = 0.0
+            var leftInset: CGFloat = 16.0
+            let rightInset: CGFloat = contextInset * 2.0 + 8.0
+            
+            if case let .editing(isSelected, isTinted) = component.selectionState {
+                leftInset += 44.0
+                let checkSize: CGFloat = 22.0
+                
+                let checkLayer: CheckLayer
+                if let current = self.checkLayer {
+                    checkLayer = current
+                    if themeUpdated {
+                        var theme = CheckNodeTheme(theme: component.theme, style: .plain)
+                        if isTinted {
+                            theme.backgroundColor = theme.backgroundColor.mixedWith(component.theme.list.itemBlocksBackgroundColor, alpha: 0.5)
+                        }
+                        checkLayer.theme = theme
+                    }
+                    checkLayer.setSelected(isSelected, animated: !transition.animation.isImmediate)
+                } else {
+                    var theme = CheckNodeTheme(theme: component.theme, style: .plain)
+                    if isTinted {
+                        theme.backgroundColor = theme.backgroundColor.mixedWith(component.theme.list.itemBlocksBackgroundColor, alpha: 0.5)
+                    }
+                    checkLayer = CheckLayer(theme: theme)
+                    self.checkLayer = checkLayer
+                    self.containerButton.layer.addSublayer(checkLayer)
+                    checkLayer.frame = CGRect(origin: CGPoint(x: -checkSize, y: floor((height - verticalInset * 2.0 - checkSize) / 2.0)), size: CGSize(width: checkSize, height: checkSize))
+                    checkLayer.setSelected(isSelected, animated: false)
+                    checkLayer.setNeedsDisplay()
+                }
+                transition.setFrame(layer: checkLayer, frame: CGRect(origin: CGPoint(x: floor((54.0 - checkSize) * 0.5), y: floor((height - verticalInset * 2.0 - checkSize) / 2.0)), size: CGSize(width: checkSize, height: checkSize)))
+            } else {
+                if let checkLayer = self.checkLayer {
+                    self.checkLayer = nil
+                    transition.setPosition(layer: checkLayer, position: CGPoint(x: -checkLayer.bounds.width * 0.5, y: checkLayer.position.y), completion: { [weak checkLayer] _ in
+                        checkLayer?.removeFromSuperlayer()
+                    })
+                }
+            }
+            
+            let previousTitleFrame = self.title.view?.frame
+            var previousTitleContents: UIView?
+            if hasSelectionUpdated && !"".isEmpty {
+                previousTitleContents = self.title.view?.snapshotView(afterScreenUpdates: false)
+            }
+            
+            let titleSize = self.title.update(
+                transition: .immediate,
+                component: AnyComponent(MultilineTextComponent(
+                    text: .plain(NSAttributedString(string: component.title, font: Font.regular(17.0), textColor: component.theme.list.itemPrimaryTextColor))
+                )),
+                environment: {},
+                containerSize: CGSize(width: availableSize.width - leftInset - rightInset, height: 100.0)
+            )
+            
+            let centralContentHeight: CGFloat = titleSize.height
+            
+            let titleFrame = CGRect(origin: CGPoint(x: leftInset, y: floor((height - verticalInset * 2.0 - centralContentHeight) / 2.0)), size: titleSize)
+            if let titleView = self.title.view {
+                if titleView.superview == nil {
+                    titleView.isUserInteractionEnabled = false
+                    self.containerButton.addSubview(titleView)
+                }
+                titleView.frame = titleFrame
+                if let previousTitleFrame, previousTitleFrame.origin.x != titleFrame.origin.x {
+                    transition.animatePosition(view: titleView, from: CGPoint(x: previousTitleFrame.origin.x - titleFrame.origin.x, y: 0.0), to: CGPoint(), additive: true)
+                }
+                
+                if let previousTitleFrame, let previousTitleContents, previousTitleFrame.size != titleSize {
+                    previousTitleContents.frame = CGRect(origin: previousTitleFrame.origin, size: previousTitleFrame.size)
+                    self.addSubview(previousTitleContents)
+                    
+                    transition.setFrame(view: previousTitleContents, frame: CGRect(origin: titleFrame.origin, size: previousTitleFrame.size))
+                    transition.setAlpha(view: previousTitleContents, alpha: 0.0, completion: { [weak previousTitleContents] _ in
+                        previousTitleContents?.removeFromSuperview()
+                    })
+                    transition.animateAlpha(view: titleView, from: 0.0, to: 1.0)
+                }
+            }
+           
+            if themeUpdated {
+                self.separatorLayer.backgroundColor = component.theme.list.itemPlainSeparatorColor.cgColor
+            }
+            let separatorLeftInset = leftInset + 44.0
+            transition.setFrame(layer: self.separatorLayer, frame: CGRect(origin: CGPoint(x: separatorLeftInset, y: height), size: CGSize(width: availableSize.width - separatorLeftInset, height: UIScreenPixel)))
+            self.separatorLayer.isHidden = !component.hasNext
+            
+            let containerFrame = CGRect(origin: CGPoint(x: contextInset, y: verticalInset), size: CGSize(width: availableSize.width - contextInset * 2.0, height: height - verticalInset * 2.0))
+            transition.setFrame(view: self.containerButton, frame: containerFrame)
+            
+            return CGSize(width: availableSize.width, height: height)
+        }
+    }
+    
+    func makeView() -> View {
+        return View(frame: CGRect())
+    }
+    
+    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/ShareWithPeersScreen/Sources/CoverListItemComponent.swift

@@ -0,0 +1,144 @@
+import Foundation
+import UIKit
+import Display
+import ComponentFlow
+import MultilineTextComponent
+import TelegramPresentationData
+import SwitchComponent
+
+final class CoverListItemComponent: Component {
+    let theme: PresentationTheme
+    let title: String
+    let image: UIImage?
+    let hasNext: Bool
+    let action: () -> Void
+    
+    init(
+        theme: PresentationTheme,
+        title: String,
+        image: UIImage?,
+        hasNext: Bool,
+        action: @escaping () -> Void
+    ) {
+        self.theme = theme
+        self.title = title
+        self.image = image
+        self.hasNext = hasNext
+        self.action = action
+    }
+    
+    static func ==(lhs: CoverListItemComponent, rhs: CoverListItemComponent) -> Bool {
+        if lhs.theme !== rhs.theme {
+            return false
+        }
+        if lhs.title != rhs.title {
+            return false
+        }
+        if lhs.image !== rhs.image {
+            return false
+        }
+        if lhs.hasNext != rhs.hasNext {
+            return false
+        }
+        return true
+    }
+    
+    final class View: UIView {
+        private let containerButton: HighlightTrackingButton
+        
+        private let title = ComponentView<Empty>()
+        private let icon = ComponentView<Empty>()
+        private let separatorLayer: SimpleLayer
+        
+        private var component: CoverListItemComponent?
+        private weak var state: EmptyComponentState?
+        
+        override init(frame: CGRect) {
+            self.separatorLayer = SimpleLayer()
+            
+            self.containerButton = HighlightTrackingButton()
+                        
+            super.init(frame: frame)
+            
+            self.layer.addSublayer(self.separatorLayer)
+            self.addSubview(self.containerButton)
+            
+            self.containerButton.addTarget(self, action: #selector(self.pressed), for: .touchUpInside)
+        }
+        
+        required init?(coder: NSCoder) {
+            fatalError("init(coder:) has not been implemented")
+        }
+        
+        @objc private func pressed() {
+            guard let component = self.component else {
+                return
+            }
+            component.action()
+        }
+        
+        func update(component: CoverListItemComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
+            let themeUpdated = self.component?.theme !== component.theme
+                     
+            self.component = component
+            self.state = state
+                        
+            let height: CGFloat = 52.0
+            let verticalInset: CGFloat = 0.0
+            let leftInset: CGFloat = 16.0
+            let rightInset: CGFloat = 16.0
+            
+            let iconSize = self.icon.update(
+                transition: .immediate,
+                component: AnyComponent(Image(image: component.image, contentMode: .scaleAspectFill)),
+                environment: {},
+                containerSize: CGSize(width: 30.0, height: 30.0)
+            )
+            
+            let titleSize = self.title.update(
+                transition: .immediate,
+                component: AnyComponent(MultilineTextComponent(
+                    text: .plain(NSAttributedString(string: component.title, font: Font.regular(17.0), textColor: component.theme.list.itemPrimaryTextColor))
+                )),
+                environment: {},
+                containerSize: CGSize(width: availableSize.width - leftInset - rightInset, height: 100.0)
+            )
+            
+            let titleFrame = CGRect(origin: CGPoint(x: leftInset, y: floorToScreenPixels((height - titleSize.height) / 2.0)), size: titleSize)
+            if let titleView = self.title.view {
+                if titleView.superview == nil {
+                    titleView.isUserInteractionEnabled = false
+                    self.containerButton.addSubview(titleView)
+                }
+                titleView.frame = titleFrame
+            }
+            if let iconView = self.icon.view {
+                if iconView.superview == nil {
+                    iconView.clipsToBounds = true
+                    iconView.layer.cornerRadius = 5.0
+                    self.containerButton.addSubview(iconView)
+                }
+                transition.setFrame(view: iconView, frame: CGRect(origin: CGPoint(x: availableSize.width - rightInset - iconSize.width, y: floorToScreenPixels((height - iconSize.height) / 2.0)), size: iconSize))
+            }
+            
+            if themeUpdated {
+                self.separatorLayer.backgroundColor = component.theme.list.itemPlainSeparatorColor.cgColor
+            }
+            transition.setFrame(layer: self.separatorLayer, frame: CGRect(origin: CGPoint(x: leftInset, y: height), size: CGSize(width: availableSize.width - leftInset, height: UIScreenPixel)))
+            self.separatorLayer.isHidden = !component.hasNext
+            
+            let containerFrame = CGRect(origin: CGPoint(x: 0.0, y: verticalInset), size: CGSize(width: availableSize.width, height: height - verticalInset * 2.0))
+            transition.setFrame(view: self.containerButton, frame: containerFrame)
+            
+            return CGSize(width: availableSize.width, height: height)
+        }
+    }
+    
+    func makeView() -> View {
+        return View(frame: CGRect())
+    }
+    
+    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/ShareWithPeersScreen/Sources/OptionListItemComponent.swift

@@ -0,0 +1,157 @@
+import Foundation
+import UIKit
+import Display
+import ComponentFlow
+import MultilineTextComponent
+import TelegramPresentationData
+import SwitchComponent
+
+final class OptionListItemComponent: Component {
+    enum SelectionState: Equatable {
+        case none
+        case editing(isSelected: Bool, isTinted: Bool)
+    }
+    
+    let theme: PresentationTheme
+    let title: String
+    let hasNext: Bool
+    let selected: Bool
+    let selectionChanged: (Bool) -> Void
+    
+    init(
+        theme: PresentationTheme,
+        title: String,
+        hasNext: Bool,
+        selected: Bool,
+        selectionChanged: @escaping (Bool) -> Void
+    ) {
+        self.theme = theme
+        self.title = title
+        self.hasNext = hasNext
+        self.selected = selected
+        self.selectionChanged = selectionChanged
+    }
+    
+    static func ==(lhs: OptionListItemComponent, rhs: OptionListItemComponent) -> Bool {
+        if lhs.theme !== rhs.theme {
+            return false
+        }
+        if lhs.title != rhs.title {
+            return false
+        }
+        if lhs.selected != rhs.selected {
+            return false
+        }
+        if lhs.hasNext != rhs.hasNext {
+            return false
+        }
+        return true
+    }
+    
+    final class View: UIView {
+        private let containerButton: HighlightTrackingButton
+        
+        private let title = ComponentView<Empty>()
+        private let switchComponent = ComponentView<Empty>()
+        private let separatorLayer: SimpleLayer
+        
+        private var component: OptionListItemComponent?
+        private weak var state: EmptyComponentState?
+        
+        override init(frame: CGRect) {
+            self.separatorLayer = SimpleLayer()
+            
+            self.containerButton = HighlightTrackingButton()
+                        
+            super.init(frame: frame)
+            
+            self.layer.addSublayer(self.separatorLayer)
+            self.addSubview(self.containerButton)
+            
+            self.containerButton.addTarget(self, action: #selector(self.pressed), for: .touchUpInside)
+        }
+        
+        required init?(coder: NSCoder) {
+            fatalError("init(coder:) has not been implemented")
+        }
+        
+        @objc private func pressed() {
+//            guard let component = self.component else {
+//                return
+//            }
+//            if case .editing(true, _) = component.selectionState {
+//                component.secondaryAction()
+//            } else {
+//                component.action()
+//            }
+        }
+        
+        func update(component: OptionListItemComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
+            let themeUpdated = self.component?.theme !== component.theme
+                     
+            self.component = component
+            self.state = state
+                        
+            let height: CGFloat = 52.0
+            let verticalInset: CGFloat = 0.0
+            let leftInset: CGFloat = 16.0
+            let rightInset: CGFloat = 16.0
+            
+            let switchSize = self.switchComponent.update(
+                transition: .immediate,
+                component: AnyComponent(SwitchComponent(
+                    tintColor: nil,
+                    value: component.selected,
+                    valueUpdated: { selected in
+                        component.selectionChanged(selected)
+                    }
+                )),
+                environment: {},
+                containerSize: CGSize(width: availableSize.width - leftInset - rightInset, height: 100.0)
+            )
+            
+            let titleSize = self.title.update(
+                transition: .immediate,
+                component: AnyComponent(MultilineTextComponent(
+                    text: .plain(NSAttributedString(string: component.title, font: Font.regular(17.0), textColor: component.theme.list.itemPrimaryTextColor))
+                )),
+                environment: {},
+                containerSize: CGSize(width: availableSize.width - leftInset - rightInset, height: 100.0)
+            )
+            
+            let titleFrame = CGRect(origin: CGPoint(x: leftInset, y: floorToScreenPixels((height - titleSize.height) / 2.0)), size: titleSize)
+            if let titleView = self.title.view {
+                if titleView.superview == nil {
+                    titleView.isUserInteractionEnabled = false
+                    self.containerButton.addSubview(titleView)
+                }
+                titleView.frame = titleFrame
+            }
+            if let switchView = self.switchComponent.view {
+                if switchView.superview == nil {
+                    self.containerButton.addSubview(switchView)
+                }
+                transition.setFrame(view: switchView, frame: CGRect(origin: CGPoint(x: availableSize.width - rightInset - switchSize.width, y: floorToScreenPixels((height - switchSize.height) / 2.0)), size: switchSize))
+            }
+            
+            if themeUpdated {
+                self.separatorLayer.backgroundColor = component.theme.list.itemPlainSeparatorColor.cgColor
+            }
+            transition.setFrame(layer: self.separatorLayer, frame: CGRect(origin: CGPoint(x: leftInset, y: height), size: CGSize(width: availableSize.width - leftInset, height: UIScreenPixel)))
+            self.separatorLayer.isHidden = !component.hasNext
+            
+            let containerFrame = CGRect(origin: CGPoint(x: 0.0, y: verticalInset), size: CGSize(width: availableSize.width, height: height - verticalInset * 2.0))
+            transition.setFrame(view: self.containerButton, frame: containerFrame)
+            
+            return CGSize(width: availableSize.width, height: height)
+        }
+    }
+    
+    func makeView() -> View {
+        return View(frame: CGRect())
+    }
+    
+    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/ShareWithPeersScreen/Sources/SectionHeaderComponent.swift

@@ -0,0 +1,164 @@
+import Foundation
+import UIKit
+import Display
+import ComponentFlow
+import TelegramPresentationData
+import MultilineTextComponent
+
+final class SectionHeaderComponent: Component {
+    let theme: PresentationTheme
+    let style: ShareWithPeersScreenComponent.Style
+    let title: String
+    let actionTitle: String?
+    let action: (() -> Void)?
+    
+    init(
+        theme: PresentationTheme,
+        style: ShareWithPeersScreenComponent.Style,
+        title: String,
+        actionTitle: String?,
+        action: (() -> Void)?
+    ) {
+        self.theme = theme
+        self.style = style
+        self.title = title
+        self.actionTitle = actionTitle
+        self.action = action
+    }
+    
+    static func ==(lhs: SectionHeaderComponent, rhs: SectionHeaderComponent) -> Bool {
+        if lhs.theme !== rhs.theme {
+            return false
+        }
+        if lhs.style != rhs.style {
+            return false
+        }
+        if lhs.title != rhs.title {
+            return false
+        }
+        if lhs.actionTitle != rhs.actionTitle {
+            return false
+        }
+        return true
+    }
+    
+    final class View: UIView {        
+        private let title = ComponentView<Empty>()
+        private let backgroundView: BlurredBackgroundView
+        private let action = ComponentView<Empty>()
+        
+        private var component: SectionHeaderComponent?
+        private weak var state: EmptyComponentState?
+        
+        override init(frame: CGRect) {            
+            self.backgroundView = BlurredBackgroundView(color: .clear, enableBlur: true)
+            
+            super.init(frame: frame)
+            
+            self.addSubview(self.backgroundView)
+        }
+        
+        required init?(coder: NSCoder) {
+            fatalError("init(coder:) has not been implemented")
+        }
+        
+        func update(component: SectionHeaderComponent, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
+            let themeUpdated = self.component?.theme !== component.theme
+            
+            self.component = component
+            self.state = state
+            
+            let height: CGFloat = 28.0
+            let leftInset: CGFloat = 16.0
+            let rightInset: CGFloat = 0.0
+            
+            let previousTitleFrame = self.title.view?.frame
+            
+            if themeUpdated {
+                switch component.style {
+                case .plain:
+                    self.backgroundView.isHidden = false
+                    self.backgroundView.updateColor(color: component.theme.rootController.navigationBar.blurredBackgroundColor, transition: .immediate)
+                case .blocks:
+                    self.backgroundView.isHidden = true
+                }
+            }
+            
+            let titleSize = self.title.update(
+                transition: .immediate,
+                component: AnyComponent(MultilineTextComponent(
+                    text: .plain(NSAttributedString(string: component.title, font: Font.regular(13.0), textColor: component.theme.list.itemSecondaryTextColor))
+                )),
+                environment: {},
+                containerSize: CGSize(width: availableSize.width - leftInset - rightInset, height: 100.0)
+            )
+            
+            let titleFrame = CGRect(origin: CGPoint(x: leftInset, y: floor((height - titleSize.height) / 2.0)), size: titleSize)
+            if let titleView = self.title.view {
+                if titleView.superview == nil {
+                    titleView.isUserInteractionEnabled = false
+                    self.addSubview(titleView)
+                }
+                titleView.frame = titleFrame
+                if let previousTitleFrame, previousTitleFrame.origin.x != titleFrame.origin.x {
+                    transition.animatePosition(view: titleView, from: CGPoint(x: previousTitleFrame.origin.x - titleFrame.origin.x, y: 0.0), to: CGPoint(), additive: true)
+                }
+            }
+            
+            if let actionTitle = component.actionTitle {
+                let actionSize = self.action.update(
+                    transition: .immediate,
+                    component: AnyComponent(
+                        Button(content: AnyComponent(MultilineTextComponent(
+                            text: .plain(NSAttributedString(string: actionTitle, font: Font.regular(13.0), textColor: component.theme.list.itemSecondaryTextColor))
+                        )), action: { [weak self] in
+                            if let self, let component = self.component {
+                                component.action?()
+                            }
+                        })
+                    ),
+                    environment: {},
+                    containerSize: CGSize(width: availableSize.width - leftInset - rightInset, height: 100.0)
+                )
+                if let view = self.action.view {
+                    if view.superview == nil {
+                        self.addSubview(view)
+                        if !transition.animation.isImmediate {
+                            view.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
+                            view.layer.animateScale(from: 0.01, to: 1.0, duration: 0.2)
+                        }
+                    }
+                    let actionFrame = CGRect(origin: CGPoint(x: availableSize.width - leftInset - actionSize.width, y: floor((height - titleSize.height) / 2.0)), size: actionSize)
+                    view.frame = actionFrame
+                }
+            } else if let view = self.action.view, view.superview != nil {
+                if !transition.animation.isImmediate {
+                    view.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.2, removeOnCompletion: false, completion: { finished in
+                        if finished {
+                            view.removeFromSuperview()
+                            view.layer.removeAllAnimations()
+                        }
+                    })
+                    view.layer.animateScale(from: 1.0, to: 0.01, duration: 0.2, removeOnCompletion: false)
+                } else {
+                    view.removeFromSuperview()
+                }
+            }
+            
+            let size = CGSize(width: availableSize.width, height: height)
+            
+            transition.setFrame(view: self.backgroundView, frame: CGRect(origin: CGPoint(), size: size))
+            self.backgroundView.update(size: size, transition: transition.containedViewLayoutTransition)
+            
+            return size
+        }
+    }
+    
+    func makeView() -> View {
+        return View(frame: CGRect())
+    }
+    
+    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/ShareWithPeersScreen/Sources/ShareWithPeersScreenState.swift

@@ -0,0 +1,750 @@
+import Foundation
+import SwiftSignalKit
+import TelegramCore
+import AccountContext
+import TelegramUIPreferences
+import TemporaryCachedPeerDataManager
+import Postbox
+
+public extension ShareWithPeersScreen {
+    final class State {
+        let sendAsPeers: [EnginePeer]
+        let peers: [EnginePeer]
+        let peersMap: [EnginePeer.Id: EnginePeer]
+        let savedSelectedPeers: [Stories.Item.Privacy.Base: [EnginePeer.Id]]
+        let presences: [EnginePeer.Id: EnginePeer.Presence]
+        let invitedAt: [EnginePeer.Id: Int32]
+        let participants: [EnginePeer.Id: Int]
+        let closeFriendsPeers: [EnginePeer]
+        let grayListPeers: [EnginePeer]
+        
+        fileprivate init(
+            sendAsPeers: [EnginePeer] = [],
+            peers: [EnginePeer],
+            peersMap: [EnginePeer.Id: EnginePeer] = [:],
+            savedSelectedPeers: [Stories.Item.Privacy.Base: [EnginePeer.Id]] = [:],
+            presences: [EnginePeer.Id: EnginePeer.Presence] = [:],
+            invitedAt: [EnginePeer.Id: Int32] = [:],
+            participants: [EnginePeer.Id: Int] = [:],
+            closeFriendsPeers: [EnginePeer] = [],
+            grayListPeers: [EnginePeer] = []
+        ) {
+            self.sendAsPeers = sendAsPeers
+            self.peers = peers
+            self.peersMap = peersMap
+            self.savedSelectedPeers = savedSelectedPeers
+            self.presences = presences
+            self.invitedAt = invitedAt
+            self.participants = participants
+            self.closeFriendsPeers = closeFriendsPeers
+            self.grayListPeers = grayListPeers
+        }
+    }
+    
+    final class StateContext {
+        public enum Subject: Equatable {
+            case peers(peers: [EnginePeer], peerId: EnginePeer.Id?)
+            case stories(editing: Bool, count: Int32)
+            case chats(blocked: Bool)
+            case contacts(base: EngineStoryPrivacy.Base)
+            case contactsSearch(query: String, onlyContacts: Bool)
+            case members(isGroup: Bool, peerId: EnginePeer.Id, searchQuery: String?)
+            case channels(isGroup: Bool, exclude: Set<EnginePeer.Id>, searchQuery: String?)
+        }
+        
+        var stateValue: State?
+        
+        public let subject: Subject
+        public let liveStream: Bool
+        public let editing: Bool
+        public private(set) var initialPeerIds: Set<EnginePeer.Id> = Set()
+        let blockedPeersContext: BlockedPeersContext?
+        
+        private var stateDisposable: Disposable?
+        private let stateSubject = Promise<State>()
+        public var state: Signal<State, NoError> {
+            return self.stateSubject.get()
+        }
+        private var listControl: PeerChannelMemberCategoryControl?
+        
+        private let readySubject = ValuePromise<Bool>(false, ignoreRepeated: true)
+        public var ready: Signal<Bool, NoError> {
+            return self.readySubject.get()
+        }
+        
+        public init(
+            context: AccountContext,
+            subject: Subject = .chats(blocked: false),
+            liveStream: Bool = false,
+            editing: Bool = false,
+            initialSelectedPeers: [EngineStoryPrivacy.Base: [EnginePeer.Id]] = [:],
+            initialPeerIds: Set<EnginePeer.Id> = Set(),
+            closeFriends: Signal<[EnginePeer], NoError> = .single([]),
+            adminedChannels: Signal<[EnginePeer], NoError> = .single([]),
+            blockedPeersContext: BlockedPeersContext? = nil
+        ) {
+            self.subject = subject
+            self.liveStream = liveStream
+            self.editing = editing
+            self.initialPeerIds = initialPeerIds
+            self.blockedPeersContext = blockedPeersContext
+            
+            let grayListPeers: Signal<[EnginePeer], NoError>
+            if let blockedPeersContext {
+                grayListPeers = blockedPeersContext.state
+                |> map { state -> [EnginePeer] in
+                    return state.peers.compactMap { $0.peer.flatMap(EnginePeer.init) }
+                }
+            } else {
+                grayListPeers = .single([])
+            }
+             
+            switch subject {
+            case let .peers(peers, _):
+                let peers = peers.filter { peer in
+                    if liveStream, case let .channel(channel) = peer, case .group = channel.info {
+                        return false
+                    } else {
+                        return true
+                    }
+                }
+                self.stateDisposable = (.single(peers)
+                |> mapToSignal { peers -> Signal<([EnginePeer], [EnginePeer.Id: Optional<Int>]), NoError> in
+                    return context.engine.data.subscribe(
+                        EngineDataMap(peers.map(\.id).map(TelegramEngine.EngineData.Item.Peer.ParticipantCount.init))
+                    )
+                    |> map { participantCountMap -> ([EnginePeer], [EnginePeer.Id: Optional<Int>]) in
+                        return (peers, participantCountMap)
+                    }
+                }
+                |> deliverOnMainQueue).start(next: { [weak self] peers, participantCounts in
+                    guard let self else {
+                        return
+                    }
+                    var participants: [EnginePeer.Id: Int] = [:]
+                    for (key, value) in participantCounts {
+                        if let value {
+                            participants[key] = value
+                        }
+                    }
+                    
+                    let state = State(
+                        sendAsPeers: peers,
+                        peers: [],
+                        participants: participants
+                    )
+                    self.stateValue = state
+                    self.stateSubject.set(.single(state))
+
+                    self.readySubject.set(true)
+                })
+            case .stories:
+                let savedEveryoneExceptionPeers = peersListStoredState(engine: context.engine, base: .everyone)
+                let savedContactsExceptionPeers = peersListStoredState(engine: context.engine, base: .contacts)
+                let savedSelectedPeers = peersListStoredState(engine: context.engine, base: .nobody)
+                
+                let savedPeers = combineLatest(
+                    savedEveryoneExceptionPeers,
+                    savedContactsExceptionPeers,
+                    savedSelectedPeers
+                ) |> mapToSignal { everyone, contacts, selected -> Signal<([EnginePeer.Id: EnginePeer], [EnginePeer.Id], [EnginePeer.Id], [EnginePeer.Id]), NoError> in
+                    var everyone = everyone
+                    if let initialPeerIds = initialSelectedPeers[.everyone] {
+                        everyone = initialPeerIds
+                    }
+                    var everyonePeerSignals: [Signal<EnginePeer?, NoError>] = []
+                    if everyone.count < 3 {
+                        for peerId in everyone {
+                            everyonePeerSignals.append(context.engine.data.get(TelegramEngine.EngineData.Item.Peer.Peer(id: peerId)))
+                        }
+                    }
+                    
+                    var contacts = contacts
+                    if let initialPeerIds = initialSelectedPeers[.contacts] {
+                        contacts = initialPeerIds
+                    }
+                    var contactsPeerSignals: [Signal<EnginePeer?, NoError>] = []
+                    if contacts.count < 3 {
+                        for peerId in contacts {
+                            contactsPeerSignals.append(context.engine.data.get(TelegramEngine.EngineData.Item.Peer.Peer(id: peerId)))
+                        }
+                    }
+                    
+                    var selected = selected
+                    if let initialPeerIds = initialSelectedPeers[.nobody] {
+                        selected = initialPeerIds
+                    }
+                    var selectedPeerSignals: [Signal<EnginePeer?, NoError>] = []
+                    if selected.count < 3 {
+                        for peerId in selected {
+                            selectedPeerSignals.append(context.engine.data.get(TelegramEngine.EngineData.Item.Peer.Peer(id: peerId)))
+                        }
+                    }
+                    return combineLatest(
+                        combineLatest(everyonePeerSignals),
+                        combineLatest(contactsPeerSignals),
+                        combineLatest(selectedPeerSignals)
+                    ) |> map { everyonePeers, contactsPeers, selectedPeers -> ([EnginePeer.Id: EnginePeer], [EnginePeer.Id], [EnginePeer.Id], [EnginePeer.Id]) in
+                        var peersMap: [EnginePeer.Id: EnginePeer] = [:]
+                        for peer in everyonePeers {
+                            if let peer {
+                                peersMap[peer.id] = peer
+                            }
+                        }
+                        for peer in contactsPeers {
+                            if let peer {
+                                peersMap[peer.id] = peer
+                            }
+                        }
+                        for peer in selectedPeers {
+                            if let peer {
+                                peersMap[peer.id] = peer
+                            }
+                        }
+                        return (
+                            peersMap,
+                            everyone,
+                            contacts,
+                            selected
+                        )
+                    }
+                }
+                
+                let adminedChannelsWithParticipants = adminedChannels
+                |> mapToSignal { peers -> Signal<([EnginePeer], [EnginePeer.Id: Optional<Int>]), NoError> in
+                    return context.engine.data.subscribe(
+                        EngineDataMap(peers.map(\.id).map(TelegramEngine.EngineData.Item.Peer.ParticipantCount.init))
+                    )
+                    |> map { participantCountMap -> ([EnginePeer], [EnginePeer.Id: Optional<Int>]) in
+                        return (peers, participantCountMap)
+                    }
+                }
+            
+                self.stateDisposable = combineLatest(
+                    queue: Queue.mainQueue(),
+                    context.engine.data.get(TelegramEngine.EngineData.Item.Peer.Peer(id: context.account.peerId)),
+                    adminedChannelsWithParticipants,
+                    savedPeers,
+                    closeFriends,
+                    grayListPeers
+                )
+                .start(next: { [weak self] accountPeer, adminedChannelsWithParticipants, savedPeers, closeFriends, grayListPeers in
+                    guard let self else {
+                        return
+                    }
+                    
+                    let (adminedChannels, participantCounts) = adminedChannelsWithParticipants
+                    var participants: [EnginePeer.Id: Int] = [:]
+                    for (key, value) in participantCounts {
+                        if let value {
+                            participants[key] = value
+                        }
+                    }
+                    
+                    var sendAsPeers: [EnginePeer] = []
+                    if let accountPeer {
+                        sendAsPeers.append(accountPeer)
+                    }
+                    for channel in adminedChannels {
+                        if case let .channel(channel) = channel, channel.hasPermission(.postStories) {
+                            if !sendAsPeers.contains(where: { $0.id == channel.id }) {
+                                sendAsPeers.append(contentsOf: adminedChannels)
+                            }
+                        }
+                    }
+
+                    let (peersMap, everyonePeers, contactsPeers, selectedPeers) = savedPeers
+                    var savedSelectedPeers: [Stories.Item.Privacy.Base: [EnginePeer.Id]] = [:]
+                    savedSelectedPeers[.everyone] = everyonePeers
+                    savedSelectedPeers[.contacts] = contactsPeers
+                    savedSelectedPeers[.nobody] = selectedPeers
+                    let state = State(
+                        sendAsPeers: sendAsPeers,
+                        peers: [],
+                        peersMap: peersMap,
+                        savedSelectedPeers: savedSelectedPeers,
+                        participants: participants,
+                        closeFriendsPeers: closeFriends,
+                        grayListPeers: grayListPeers
+                    )
+                    
+                    self.stateValue = state
+                    self.stateSubject.set(.single(state))
+                    
+                    self.readySubject.set(true)
+                })
+            case let .chats(isGrayList):
+                self.stateDisposable = (combineLatest(
+                    context.engine.messages.chatList(group: .root, count: 200) |> take(1),
+                    context.engine.data.get(TelegramEngine.EngineData.Item.Contacts.List(includePresences: true)),
+                    context.engine.data.get(EngineDataMap(Array(self.initialPeerIds).map(TelegramEngine.EngineData.Item.Peer.Peer.init))),
+                    grayListPeers
+                )
+                |> mapToSignal { chatList, contacts, initialPeers, grayListPeers -> Signal<(EngineChatList, EngineContactList, [EnginePeer.Id: Optional<EnginePeer>], [EnginePeer.Id: Optional<Int>], [EnginePeer]), NoError> in
+                    return context.engine.data.subscribe(
+                        EngineDataMap(chatList.items.map(\.renderedPeer.peerId).map(TelegramEngine.EngineData.Item.Peer.ParticipantCount.init))
+                    )
+                    |> map { participantCountMap -> (EngineChatList, EngineContactList, [EnginePeer.Id: Optional<EnginePeer>], [EnginePeer.Id: Optional<Int>], [EnginePeer]) in
+                        return (chatList, contacts, initialPeers, participantCountMap, grayListPeers)
+                    }
+                }
+                |> deliverOnMainQueue).start(next: { [weak self] chatList, contacts, initialPeers, participantCounts, grayListPeers in
+                    guard let self else {
+                        return
+                    }
+                    
+                    var participants: [EnginePeer.Id: Int] = [:]
+                    for (key, value) in participantCounts {
+                        if let value {
+                            participants[key] = value
+                        }
+                    }
+                    
+                    var grayListPeersIds = Set<EnginePeer.Id>()
+                    for peer in grayListPeers {
+                        grayListPeersIds.insert(peer.id)
+                    }
+                    
+                    var existingIds = Set<EnginePeer.Id>()
+                    var selectedPeers: [EnginePeer] = []
+                    
+                    if isGrayList {
+                        self.initialPeerIds = Set(grayListPeers.map { $0.id })
+                    }
+                    
+                    for item in chatList.items.reversed() {
+                        if let peer = item.renderedPeer.peer {
+                            if self.initialPeerIds.contains(peer.id) || isGrayList && grayListPeersIds.contains(peer.id) {
+                                selectedPeers.append(peer)
+                                existingIds.insert(peer.id)
+                            }
+                        }
+                    }
+                    
+                    for peerId in self.initialPeerIds {
+                        if !existingIds.contains(peerId), let maybePeer = initialPeers[peerId], let peer = maybePeer {
+                            selectedPeers.append(peer)
+                            existingIds.insert(peerId)
+                        }
+                    }
+                    
+                    if isGrayList {
+                        for peer in grayListPeers {
+                            if !existingIds.contains(peer.id) {
+                                selectedPeers.append(peer)
+                                existingIds.insert(peer.id)
+                            }
+                        }
+                    }
+                    
+                    var presences: [EnginePeer.Id: EnginePeer.Presence] = [:]
+                    for item in chatList.items {
+                        presences[item.renderedPeer.peerId] = item.presence
+                    }
+                    
+                    var peers: [EnginePeer] = []
+                    peers = chatList.items.filter { peer in
+                        if let peer = peer.renderedPeer.peer {
+                            if case .secretChat = peer {
+                                return false
+                            }
+                            if self.initialPeerIds.contains(peer.id) {
+                                return false
+                            }
+                            if peer.id == context.account.peerId {
+                                return false
+                            }
+                            if peer.isService || peer.isDeleted {
+                                return false
+                            }
+                            if case let .user(user) = peer {
+                                if user.botInfo != nil {
+                                    return false
+                                }
+                            }
+                            if case let .channel(channel) = peer {
+                                if case .broadcast = channel.info {
+                                    return false
+                                }
+                            }
+                            return true
+                        } else {
+                            return false
+                        }
+                    }.reversed().compactMap { $0.renderedPeer.peer }
+                    for peer in peers {
+                        existingIds.insert(peer.id)
+                    }
+                    peers.insert(contentsOf: selectedPeers, at: 0)
+                    
+                    let state = State(
+                        peers: peers,
+                        presences: presences,
+                        participants: participants,
+                        grayListPeers: grayListPeers
+                    )
+                    self.stateValue = state
+                    self.stateSubject.set(.single(state))
+                    
+                    self.readySubject.set(true)
+                })
+            case let .contacts(base):
+                self.stateDisposable = (context.engine.data.subscribe(
+                    TelegramEngine.EngineData.Item.Contacts.List(includePresences: true)
+                )
+                |> deliverOnMainQueue).start(next: { [weak self] contactList in
+                    guard let self else {
+                        return
+                    }
+                    
+                    var selectedPeers: [EnginePeer] = []
+                    if case .closeFriends = base {
+                        for peer in contactList.peers {
+                            if case let .user(user) = peer, user.flags.contains(.isCloseFriend) {
+                                selectedPeers.append(peer)
+                            }
+                        }
+                        self.initialPeerIds = Set(selectedPeers.map { $0.id })
+                    } else {
+                        for peer in contactList.peers {
+                            if case let .user(user) = peer, initialPeerIds.contains(user.id), !user.isDeleted {
+                                selectedPeers.append(peer)
+                            }
+                        }
+                        self.initialPeerIds = initialPeerIds
+                    }
+                    selectedPeers = selectedPeers.sorted(by: { lhs, rhs in
+                        let result = lhs.indexName.isLessThan(other: rhs.indexName, ordering: .firstLast)
+                        if result == .orderedSame {
+                            return lhs.id < rhs.id
+                        } else {
+                            return result == .orderedAscending
+                        }
+                    })
+                    
+                    var peers: [EnginePeer] = []
+                    peers = contactList.peers.filter { !self.initialPeerIds.contains($0.id) && $0.id != context.account.peerId && !$0.isDeleted }.sorted(by: { lhs, rhs in
+                        let result = lhs.indexName.isLessThan(other: rhs.indexName, ordering: .firstLast)
+                        if result == .orderedSame {
+                            return lhs.id < rhs.id
+                        } else {
+                            return result == .orderedAscending
+                        }
+                    })
+                    peers.insert(contentsOf: selectedPeers, at: 0)
+                    
+                    let state = State(
+                        peers: peers,
+                        presences: contactList.presences
+                    )
+                                        
+                    self.stateValue = state
+                    self.stateSubject.set(.single(state))
+                    
+                    self.readySubject.set(true)
+                })
+            case let .contactsSearch(query, onlyContacts):
+                let signal: Signal<([EngineRenderedPeer], [EnginePeer.Id: Optional<EnginePeer.Presence>], [EnginePeer.Id: Optional<Int>]), NoError>
+                if onlyContacts {
+                    signal = combineLatest(
+                        context.engine.contacts.searchLocalPeers(query: query),
+                        context.engine.contacts.searchContacts(query: query)
+                    )
+                    |> map { peers, contacts in
+                        let contactIds = Set(contacts.0.map { $0.id })
+                        return (peers.filter { contactIds.contains($0.peerId) }, [:], [:])
+                    }
+                } else {
+                    signal = context.engine.contacts.searchLocalPeers(query: query)
+                    |> mapToSignal { peers in
+                        return context.engine.data.subscribe(
+                            EngineDataMap(peers.map(\.peerId).map(TelegramEngine.EngineData.Item.Peer.Presence.init)),
+                            EngineDataMap(peers.map(\.peerId).map(TelegramEngine.EngineData.Item.Peer.ParticipantCount.init))
+                        )
+                        |> map { presenceMap, participantCountMap -> ([EngineRenderedPeer], [EnginePeer.Id: Optional<EnginePeer.Presence>], [EnginePeer.Id: Optional<Int>]) in
+                            return (peers, presenceMap, participantCountMap)
+                        }
+                    }
+                }
+                self.stateDisposable = (signal
+                |> deliverOnMainQueue).start(next: { [weak self] peers, presenceMap, participantCounts in
+                    guard let self else {
+                        return
+                    }
+                    
+                    var presences: [EnginePeer.Id: EnginePeer.Presence] = [:]
+                    for (key, value) in presenceMap {
+                        if let value {
+                            presences[key] = value
+                        }
+                    }
+                    
+                    var participants: [EnginePeer.Id: Int] = [:]
+                    for (key, value) in participantCounts {
+                        if let value {
+                            participants[key] = value
+                        }
+                    }
+                                                            
+                    let state = State(
+                        peers: peers.compactMap { $0.peer }.filter { peer in
+                            if case .secretChat = peer {
+                                return false
+                            } else if case let .user(user) = peer {
+                                if user.id == context.account.peerId {
+                                    return false
+                                } else if user.botInfo != nil {
+                                    return false
+                                } else if peer.isService {
+                                    return false
+                                } else if user.isDeleted {
+                                    return false
+                                } else {
+                                    return true
+                                }
+                            } else if case let .channel(channel) = peer {
+                                if case .broadcast = channel.info {
+                                    return false
+                                }
+                                return true
+                            } else {
+                                return true
+                            }
+                        },
+                        presences: presences,
+                        participants: participants
+                    )
+                    self.stateValue = state
+                    self.stateSubject.set(.single(state))
+                    
+                    self.readySubject.set(true)
+                })
+            case let .members(_, peerId, searchQuery):
+                let membersState = Promise<ChannelMemberListState>()
+                let contactsState = Promise<ChannelMemberListState>()
+
+                let disposableAndLoadMoreControl: (Disposable, PeerChannelMemberCategoryControl?)
+                disposableAndLoadMoreControl = context.peerChannelMemberCategoriesContextsManager.recent(engine: context.engine, postbox: context.account.postbox, network: context.account.network, accountPeerId: context.account.peerId, peerId: peerId, searchQuery: searchQuery, updated: { state in
+                    membersState.set(.single(state))
+                })
+                
+                let contactsDisposableAndLoadMoreControl = context.peerChannelMemberCategoriesContextsManager.contacts(engine: context.engine, postbox: context.account.postbox, network: context.account.network, accountPeerId: context.account.peerId, peerId: peerId, searchQuery: searchQuery, updated: { state in
+                    contactsState.set(.single(state))
+                })
+                
+                let dataDisposable = combineLatest(
+                    queue: Queue.mainQueue(),
+                    contactsState.get(),
+                    membersState.get()
+                ).startStrict(next: { [weak self] contactsState, memberState in
+                    guard let self else {
+                        return
+                    }
+                    var peers: [EnginePeer] = []
+                    var invitedAt: [EnginePeer.Id: Int32] = [:]
+                    
+                    var existingPeersIds = Set<EnginePeer.Id>()
+                    for participant in contactsState.list {
+                        if participant.peer.isDeleted || existingPeersIds.contains(participant.peer.id) || participant.participant.adminInfo != nil {
+                            continue
+                        }
+                        
+                        if case let .member(_, date, _, _, _, _) = participant.participant {
+                            invitedAt[participant.peer.id] = date
+                        } else {
+                            continue
+                        }
+                        
+                        peers.append(EnginePeer(participant.peer))
+                        existingPeersIds.insert(participant.peer.id)
+                    }
+                    
+                    for participant in memberState.list {
+                        if participant.peer.isDeleted || existingPeersIds.contains(participant.peer.id) || participant.participant.adminInfo != nil {
+                            continue
+                        }
+                        if let user = participant.peer as? TelegramUser, user.botInfo != nil {
+                            continue
+                        }
+                        
+                        if case let .member(_, date, _, _, _, _) = participant.participant {
+                            invitedAt[participant.peer.id] = date
+                        } else {
+                            continue
+                        }
+                        
+                        peers.append(EnginePeer(participant.peer))
+                    }
+                    
+                    let state = State(
+                        peers: peers,
+                        invitedAt: invitedAt
+                    )
+                    self.stateValue = state
+                    self.stateSubject.set(.single(state))
+                    
+                    self.readySubject.set(true)
+                })
+                
+                let combinedDisposable = DisposableSet()
+                combinedDisposable.add(contactsDisposableAndLoadMoreControl.0)
+                combinedDisposable.add(disposableAndLoadMoreControl.0)
+                combinedDisposable.add(dataDisposable)
+                
+                self.stateDisposable = combinedDisposable
+                
+                self.listControl = disposableAndLoadMoreControl.1
+            case let .channels(_, excludePeerIds, searchQuery):
+                self.stateDisposable = (combineLatest(
+                    context.engine.messages.chatList(group: .root, count: 500) |> take(1),
+                    searchQuery.flatMap { context.engine.contacts.searchLocalPeers(query: $0) } ?? .single([]),
+                    context.engine.data.get(EngineDataMap(Array(self.initialPeerIds).map(TelegramEngine.EngineData.Item.Peer.Peer.init)))
+                )
+                |> mapToSignal { chatList, searchResults, initialPeers -> Signal<(EngineChatList, [EngineRenderedPeer], [EnginePeer.Id: Optional<EnginePeer>], [EnginePeer.Id: Optional<Int>]), NoError> in
+                    var peerIds: [EnginePeer.Id] = []
+                    peerIds.append(contentsOf: chatList.items.map(\.renderedPeer.peerId))
+                    peerIds.append(contentsOf: searchResults.map(\.peerId))
+                    peerIds.append(contentsOf: initialPeers.compactMap(\.value?.id))
+                    return context.engine.data.subscribe(
+                        EngineDataMap(chatList.items.map(\.renderedPeer.peerId).map(TelegramEngine.EngineData.Item.Peer.ParticipantCount.init))
+                    )
+                    |> map { participantCountMap -> (EngineChatList, [EngineRenderedPeer], [EnginePeer.Id: Optional<EnginePeer>], [EnginePeer.Id: Optional<Int>]) in
+                        return (chatList, searchResults, initialPeers, participantCountMap)
+                    }
+                }
+                |> deliverOnMainQueue).start(next: { [weak self] chatList, searchResults, initialPeers, participantCounts in
+                    guard let self else {
+                        return
+                    }
+                    
+                    var participants: [EnginePeer.Id: Int] = [:]
+                    for (key, value) in participantCounts {
+                        if let value {
+                            participants[key] = value
+                        }
+                    }
+                    
+                    var existingIds = Set<EnginePeer.Id>()
+                    var selectedPeers: [EnginePeer] = []
+                                                         
+                    for item in chatList.items.reversed() {
+                        if let peer = item.renderedPeer.peer {
+                            if self.initialPeerIds.contains(peer.id) {
+                                selectedPeers.append(peer)
+                                existingIds.insert(peer.id)
+                            }
+                        }
+                    }
+                    
+                    for peerId in self.initialPeerIds {
+                        if !existingIds.contains(peerId), let maybePeer = initialPeers[peerId], let peer = maybePeer {
+                            selectedPeers.append(peer)
+                            existingIds.insert(peerId)
+                        }
+                    }
+                    
+                    for item in searchResults {
+                        if let peer = item.peer, case .channel = peer {
+                            selectedPeers.append(peer)
+                            existingIds.insert(peer.id)
+                        }
+                    }
+                 
+                    let queryTokens = stringIndexTokens(searchQuery ?? "", transliteration: .combined)
+                    func peerMatchesTokens(peer: EnginePeer, tokens: [ValueBoxKey]) -> Bool {
+                        if matchStringIndexTokens(peer.indexName._asIndexName().indexTokens, with: queryTokens) {
+                            return true
+                        }
+                        return false
+                    }
+                    
+                    var peers: [EnginePeer] = []
+                    peers = chatList.items.filter { peer in
+                        if let peer = peer.renderedPeer.peer {
+                            if existingIds.contains(peer.id) {
+                                return false
+                            }
+                            if excludePeerIds.contains(peer.id) {
+                                return false
+                            }
+                            if peer.isFake || peer.isScam {
+                                return false
+                            }
+                            if let _ = searchQuery, !peerMatchesTokens(peer: peer, tokens: queryTokens) {
+                                return false
+                            }
+                            if self.initialPeerIds.contains(peer.id) {
+                                return false
+                            }
+                            if case .channel = peer {
+                                return true
+                            }
+                            return false
+                        } else {
+                            return false
+                        }
+                    }.reversed().compactMap { $0.renderedPeer.peer }
+                    for peer in peers {
+                        existingIds.insert(peer.id)
+                    }
+                    peers.insert(contentsOf: selectedPeers, at: 0)
+                    
+                    let state = State(
+                        peers: peers,
+                        participants: participants
+                    )
+                    self.stateValue = state
+                    self.stateSubject.set(.single(state))
+                    
+                    self.readySubject.set(true)
+                })
+            }
+        }
+        
+        deinit {
+            self.stateDisposable?.dispose()
+        }
+    }
+}
+
+final class PeersListStoredState: Codable {
+    private enum CodingKeys: String, CodingKey {
+        case peerIds
+    }
+    
+    public let peerIds: [EnginePeer.Id]
+    
+    public init(peerIds: [EnginePeer.Id]) {
+        self.peerIds = peerIds
+    }
+    
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+
+        self.peerIds = try container.decode([Int64].self, forKey: .peerIds).map { EnginePeer.Id($0) }
+    }
+    
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+
+        try container.encode(self.peerIds.map { $0.toInt64() }, forKey: .peerIds)
+    }
+}
+
+func peersListStoredState(engine: TelegramEngine, base: Stories.Item.Privacy.Base) -> Signal<[EnginePeer.Id], NoError> {
+    let key = EngineDataBuffer(length: 4)
+    key.setInt32(0, value: base.rawValue)
+    
+    return engine.data.get(TelegramEngine.EngineData.Item.ItemCache.Item(collectionId: ApplicationSpecificItemCacheCollectionId.shareWithPeersState, id: key))
+    |> map { entry -> [EnginePeer.Id] in
+        return entry?.get(PeersListStoredState.self)?.peerIds ?? []
+    }
+}
+
+func updatePeersListStoredState(engine: TelegramEngine, base: Stories.Item.Privacy.Base, peerIds: [EnginePeer.Id]) -> Signal<Never, NoError> {
+    let key = EngineDataBuffer(length: 4)
+    key.setInt32(0, value: base.rawValue)
+    
+    let state = PeersListStoredState(peerIds: peerIds)
+    return engine.itemCache.put(collectionId: ApplicationSpecificItemCacheCollectionId.shareWithPeersState, id: key, item: state)
+}