chore: migrate to new version + fixed several critical bugs

- Migrated project to latest Telegram iOS base (v12.3.2+)
- Fixed circular dependency between GhostModeManager and MiscSettingsManager
- Fixed multiple Bazel build configuration errors (select() default conditions)
- Fixed duplicate type definitions in PeerInfoScreen
- Fixed swiftmodule directory resolution in build scripts
- Added Ghostgram Settings tab in main Settings menu with all 5 features
- Cleared sensitive credentials from config.json (template-only now)
- Excluded bazel-cache from version control

submodules/TelegramUI/Components/ChatThemeScreen/BUILD

@@ -37,6 +37,9 @@ swift_library(
         "//submodules/AppBundle",
         "//submodules/ActivityIndicator",
         "//submodules/TelegramUI/Components/Gifts/GiftItemComponent",
+        "//submodules/TelegramUI/Components/AlertComponent",
+        "//submodules/TelegramUI/Components/AlertComponent/AlertTransferHeaderComponent",
+        "//submodules/TelegramUI/Components/AvatarComponent",
     ],
     visibility = [
         "//visibility:public",

submodules/TelegramUI/Components/ChatThemeScreen/Sources/ChatThemeScreen.swift

@@ -22,6 +22,7 @@ import TelegramAnimatedStickerNode
 import ShimmerEffect
 import AttachmentUI
 import AvatarNode
+import AlertComponent
 
 private struct ThemeSettingsThemeEntry: Comparable, Identifiable {
     let index: Int
@@ -308,7 +309,7 @@ private final class ThemeSettingsThemeItemIconNode : ListViewItemNode {
         
         self.placeholderNode = StickerShimmerEffectNode()
 
-        super.init(layerBacked: false, dynamicBounce: false, rotated: false, seeThrough: false)
+        super.init(layerBacked: false, rotated: false, seeThrough: false)
         
         self.addSubnode(self.containerNode)
         self.containerNode.addSubnode(self.imageNode)
@@ -925,7 +926,7 @@ private class ChatThemeScreenNode: ViewControllerTracingNode, ASScrollViewDelega
         self.animationNode = AnimationNode(animation: self.isDarkAppearance ? "anim_sun_reverse" : "anim_sun", colors: iconColors(theme: self.presentationData.theme), scale: 1.0)
         self.animationNode.isUserInteractionEnabled = false
         
-        self.doneButton = SolidRoundedButtonNode(theme: SolidRoundedButtonTheme(theme: self.presentationData.theme), height: 50.0, cornerRadius: 11.0)
+        self.doneButton = SolidRoundedButtonNode(theme: SolidRoundedButtonTheme(theme: self.presentationData.theme), glass: true, height: 52.0, cornerRadius: 26.0)
         
         self.otherButton = HighlightableButtonNode()
         
@@ -1530,7 +1531,7 @@ private class ChatThemeScreenNode: ViewControllerTracingNode, ASScrollViewDelega
     override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
         var presentingAlertController = false
         self.controller?.forEachController({ c in
-            if c is AlertController {
+            if c is AlertScreen {
                 presentingAlertController = true
             }
             return true
@@ -1605,13 +1606,14 @@ private class ChatThemeScreenNode: ViewControllerTracingNode, ASScrollViewDelega
         let cancelFrame = CGRect(origin: CGPoint(x: 16.0, y: 0.0), size: cancelSize)
         transition.updateFrame(node: self.cancelButtonNode, frame: cancelFrame)
 
+        let buttonInsets = ContainerViewLayout.concentricInsets(bottomInset: layout.intrinsicInsets.bottom, innerDiameter: 52.0, sideInset: 30.0)
         let buttonInset: CGFloat = 16.0
-        let doneButtonHeight = self.doneButton.updateLayout(width: contentFrame.width - buttonInset * 2.0, transition: transition)
+        let doneButtonHeight = self.doneButton.updateLayout(width: contentFrame.width - buttonInsets.left - buttonInsets.right, transition: transition)
         var doneY = contentHeight - doneButtonHeight - 2.0 - insets.bottom
         if self.controller?.canResetWallpaper == true {
             doneY = contentHeight - doneButtonHeight - 52.0 - insets.bottom
         }
-        transition.updateFrame(node: self.doneButton, frame: CGRect(x: buttonInset, y: doneY, width: contentFrame.width, height: doneButtonHeight))
+        transition.updateFrame(node: self.doneButton, frame: CGRect(x: buttonInsets.left, y: doneY, width: contentFrame.width, height: doneButtonHeight))
         
         let otherButtonSize = self.otherButton.measure(CGSize(width: contentFrame.width - buttonInset * 2.0, height: .greatestFiniteMagnitude))
         self.otherButton.frame = CGRect(origin: CGPoint(x: floor((contentFrame.width - otherButtonSize.width) / 2.0), y: contentHeight - otherButtonSize.height - insets.bottom - 15.0), size: otherButtonSize)

submodules/TelegramUI/Components/ChatThemeScreen/Sources/GiftThemeTransferAlertController.swift

@@ -3,293 +3,65 @@ import UIKit
 import AsyncDisplayKit
 import Display
 import ComponentFlow
-import Postbox
 import TelegramCore
 import TelegramPresentationData
-import TelegramUIPreferences
 import AccountContext
-import AppBundle
-import AvatarNode
-import Markdown
+import AlertComponent
+import AlertTransferHeaderComponent
 import GiftItemComponent
-import ActivityIndicator
-
-private final class GiftThemeTransferAlertContentNode: AlertContentNode {
-    private let context: AccountContext
-    private let strings: PresentationStrings
-    private var presentationTheme: PresentationTheme
-    private let title: String
-    private let text: String
-    private let gift: StarGift.UniqueGift
-    
-    private let titleNode: ASTextNode
-    private let giftView = ComponentView<Empty>()
-    private let textNode: ASTextNode
-    private let arrowNode: ASImageNode
-    private let avatarNode: AvatarNode
-    
-    private let actionNodesSeparator: ASDisplayNode
-    private let actionNodes: [TextAlertContentActionNode]
-    private let actionVerticalSeparators: [ASDisplayNode]
-    
-    private var activityIndicator: ActivityIndicator?
-        
-    private var validLayout: CGSize?
-    
-    var inProgress = false {
-        didSet {
-            if let size = self.validLayout {
-                let _ = self.updateLayout(size: size, transition: .immediate)
-            }
-        }
-    }
-    
-    override var dismissOnOutsideTap: Bool {
-        return self.isUserInteractionEnabled
-    }
-    
-    init(
-        context: AccountContext,
-        theme: AlertControllerTheme,
-        ptheme: PresentationTheme,
-        strings: PresentationStrings,
-        gift: StarGift.UniqueGift,
-        peer: EnginePeer,
-        title: String,
-        text: String,
-        actions: [TextAlertAction]
-    ) {
-        self.context = context
-        self.strings = strings
-        self.presentationTheme = ptheme
-        self.title = title
-        self.text = text
-        self.gift = gift
-        
-        self.titleNode = ASTextNode()
-        self.titleNode.maximumNumberOfLines = 0
-        
-        self.textNode = ASTextNode()
-        self.textNode.maximumNumberOfLines = 0
-        
-        self.arrowNode = ASImageNode()
-        self.arrowNode.displaysAsynchronously = false
-        self.arrowNode.displayWithoutProcessing = true
-        
-        self.avatarNode = AvatarNode(font: avatarPlaceholderFont(size: 26.0))
-        
-        self.actionNodesSeparator = ASDisplayNode()
-        self.actionNodesSeparator.isLayerBacked = true
-        
-        self.actionNodes = actions.map { action -> TextAlertContentActionNode in
-            return TextAlertContentActionNode(theme: theme, action: action)
-        }
-        
-        var actionVerticalSeparators: [ASDisplayNode] = []
-        if actions.count > 1 {
-            for _ in 0 ..< actions.count - 1 {
-                let separatorNode = ASDisplayNode()
-                separatorNode.isLayerBacked = true
-                actionVerticalSeparators.append(separatorNode)
-            }
-        }
-        self.actionVerticalSeparators = actionVerticalSeparators
-        
-        super.init()
-        
-        self.addSubnode(self.titleNode)
-        self.addSubnode(self.textNode)
-        self.addSubnode(self.arrowNode)
-        self.addSubnode(self.avatarNode)
-    
-        self.addSubnode(self.actionNodesSeparator)
-        
-        for actionNode in self.actionNodes {
-            self.addSubnode(actionNode)
-        }
-        
-        for separatorNode in self.actionVerticalSeparators {
-            self.addSubnode(separatorNode)
-        }
-        
-        self.updateTheme(theme)
-        
-        self.avatarNode.setPeer(context: context, theme: ptheme, peer: peer)
-    }
-    
-    override func updateTheme(_ theme: AlertControllerTheme) {
-        self.titleNode.attributedText = NSAttributedString(string: self.title, font: Font.semibold(17.0), textColor: theme.primaryColor)
-        self.textNode.attributedText = parseMarkdownIntoAttributedString(self.text, attributes: MarkdownAttributes(
-            body: MarkdownAttributeSet(font: Font.regular(13.0), textColor: theme.primaryColor),
-            bold: MarkdownAttributeSet(font: Font.semibold(13.0), textColor: theme.primaryColor),
-            link: MarkdownAttributeSet(font: Font.regular(13.0), textColor: theme.primaryColor),
-            linkAttribute: { url in
-                return ("URL", url)
-            }
-        ), textAlignment: .center)
-        self.arrowNode.image = generateTintedImage(image: UIImage(bundleImageName: "Media Editor/CutoutUndo"), color: theme.secondaryColor.withAlphaComponent(0.9))
-        
-        self.actionNodesSeparator.backgroundColor = theme.separatorColor
-        for actionNode in self.actionNodes {
-            actionNode.updateTheme(theme)
-        }
-        for separatorNode in self.actionVerticalSeparators {
-            separatorNode.backgroundColor = theme.separatorColor
-        }
-        
-        if let size = self.validLayout {
-            _ = self.updateLayout(size: size, transition: .immediate)
-        }
-    }
-    
-    override func updateLayout(size: CGSize, transition: ContainedViewLayoutTransition) -> CGSize {
-        var size = size
-        size.width = min(size.width, 270.0)
-        
-        self.validLayout = size
-        
-        var origin: CGPoint = CGPoint(x: 0.0, y: 20.0)
-        
-        let avatarSize = CGSize(width: 60.0, height: 60.0)
-        self.avatarNode.updateSize(size: avatarSize)
-        
-        let giftFrame = CGRect(origin: CGPoint(x: floorToScreenPixels((size.width - avatarSize.width) / 2.0) - 52.0, y: origin.y), size: avatarSize)
-        
-        let _ = self.giftView.update(
-            transition: .immediate,
-            component: AnyComponent(
-                GiftItemComponent(
-                    context: self.context,
-                    theme: self.presentationTheme,
-                    strings: self.strings,
-                    peer: nil,
-                    subject: .uniqueGift(gift: self.gift, price: nil),
-                    mode: .thumbnail
-                )
-            ),
-            environment: {},
-            containerSize: avatarSize
-        )
-        if let view = self.giftView.view {
-            if view.superview == nil {
-                self.view.addSubview(view)
-            }
-            view.frame = giftFrame
-        }
-        
-        if let arrowImage = self.arrowNode.image {
-            let arrowFrame = CGRect(origin: CGPoint(x: floorToScreenPixels((size.width - arrowImage.size.width) / 2.0), y: origin.y + floorToScreenPixels((avatarSize.height - arrowImage.size.height) / 2.0)), size: arrowImage.size)
-            transition.updateFrame(node: self.arrowNode, frame: arrowFrame)
-        }
-        
-        let avatarFrame = CGRect(origin: CGPoint(x: floorToScreenPixels((size.width - avatarSize.width) / 2.0) + 52.0, y: origin.y), size: avatarSize)
-        transition.updateFrame(node: self.avatarNode, frame: avatarFrame)
-                
-        origin.y += avatarSize.height + 17.0
-        
-        let titleSize = self.titleNode.measure(CGSize(width: size.width - 32.0, height: size.height))
-        transition.updateFrame(node: self.titleNode, frame: CGRect(origin: CGPoint(x: floorToScreenPixels((size.width - titleSize.width) / 2.0), y: origin.y), size: titleSize))
-        origin.y += titleSize.height + 5.0
-        
-        let textSize = self.textNode.measure(CGSize(width: size.width - 32.0, height: size.height))
-        transition.updateFrame(node: self.textNode, frame: CGRect(origin: CGPoint(x: floorToScreenPixels((size.width - textSize.width) / 2.0), y: origin.y), size: textSize))
-        origin.y += textSize.height + 10.0
-        
-        let actionButtonHeight: CGFloat = 44.0
-        var minActionsWidth: CGFloat = 0.0
-        let maxActionWidth: CGFloat = floor(size.width / CGFloat(self.actionNodes.count))
-        let actionTitleInsets: CGFloat = 8.0
-        
-        for actionNode in self.actionNodes {
-            let actionTitleSize = actionNode.titleNode.updateLayout(CGSize(width: maxActionWidth, height: actionButtonHeight))
-            minActionsWidth += actionTitleSize.width + actionTitleInsets
-        }
-        
-        let insets = UIEdgeInsets(top: 18.0, left: 18.0, bottom: 18.0, right: 18.0)
-        
-        let contentWidth = max(size.width, minActionsWidth)
-                
-        let actionsHeight = actionButtonHeight
-        
-        let resultSize = CGSize(width: contentWidth, height: avatarSize.height + titleSize.height + textSize.height + actionsHeight + 24.0 + insets.top + insets.bottom)
-        self.actionNodesSeparator.frame = CGRect(origin: CGPoint(x: 0.0, y: resultSize.height - actionsHeight - UIScreenPixel), size: CGSize(width: resultSize.width, height: UIScreenPixel))
-        
-        var actionOffset: CGFloat = 0.0
-        let actionWidth: CGFloat = floor(resultSize.width / CGFloat(self.actionNodes.count))
-        var separatorIndex = -1
-        var nodeIndex = 0
-        for actionNode in self.actionNodes {
-            if separatorIndex >= 0 {
-                let separatorNode = self.actionVerticalSeparators[separatorIndex]
-                transition.updateFrame(node: separatorNode, frame: CGRect(origin: CGPoint(x: actionOffset - UIScreenPixel, y: resultSize.height - actionsHeight), size: CGSize(width: UIScreenPixel, height: actionsHeight - UIScreenPixel)))
-            }
-            separatorIndex += 1
-            
-            let currentActionWidth: CGFloat
-            if nodeIndex == self.actionNodes.count - 1 {
-                currentActionWidth = resultSize.width - actionOffset
-            } else {
-                currentActionWidth = actionWidth
-            }
-            
-            let actionNodeFrame: CGRect
-            actionNodeFrame = CGRect(origin: CGPoint(x: actionOffset, y: resultSize.height - actionsHeight), size: CGSize(width: currentActionWidth, height: actionButtonHeight))
-            actionOffset += currentActionWidth
-            
-            transition.updateFrame(node: actionNode, frame: actionNodeFrame)
-            
-            nodeIndex += 1
-        }
-        
-        if self.inProgress {
-            let activityIndicator: ActivityIndicator
-            if let current = self.activityIndicator {
-                activityIndicator = current
-            } else {
-                activityIndicator = ActivityIndicator(type: .custom(self.presentationTheme.list.freeInputField.controlColor, 18.0, 1.5, false))
-                self.addSubnode(activityIndicator)
-            }
-            
-            if let actionNode = self.actionNodes.first {
-                actionNode.isHidden = true
-                
-                let indicatorSize = CGSize(width: 22.0, height: 22.0)
-                transition.updateFrame(node: activityIndicator, frame: CGRect(origin: CGPoint(x: actionNode.frame.minX + floor((actionNode.frame.width - indicatorSize.width) / 2.0), y: actionNode.frame.minY + floor((actionNode.frame.height - indicatorSize.height) / 2.0)), size: indicatorSize))
-            }
-        }
-        
-        return resultSize
-    }
-}
+import AvatarComponent
 
 public func giftThemeTransferAlertController(
     context: AccountContext,
     gift: StarGift.UniqueGift,
     previousPeer: EnginePeer,
     commit: @escaping () -> Void
-) -> AlertController {
+) -> ViewController {
     let presentationData = context.sharedContext.currentPresentationData.with { $0 }
     let strings = presentationData.strings
-        
-    var contentNode: GiftThemeTransferAlertContentNode?
-    var dismissImpl: ((Bool) -> Void)?
-    let actions: [TextAlertAction] = [TextAlertAction(type: .genericAction, title: presentationData.strings.Common_Cancel, action: {
-        dismissImpl?(true)
-    }), TextAlertAction(type: .defaultAction, title: presentationData.strings.Conversation_Theme_GiftTransfer_Proceed, action: {
-        dismissImpl?(true)
-        commit()
-    })]
     
-    let text = strings.Conversation_Theme_GiftTransfer_Text(previousPeer.compactDisplayTitle).string
-    contentNode = GiftThemeTransferAlertContentNode(context: context, theme: AlertControllerTheme(presentationData: presentationData), ptheme: presentationData.theme, strings: strings, gift: gift, peer: previousPeer, title: "", text: text, actions: actions)
+    var content: [AnyComponentWithIdentity<AlertComponentEnvironment>] = []
+    content.append(AnyComponentWithIdentity(
+        id: "header",
+        component: AnyComponent(
+            AlertTransferHeaderComponent(
+                fromComponent: AnyComponentWithIdentity(id: "gift", component: AnyComponent(
+                    GiftItemComponent(
+                        context: context,
+                        theme: presentationData.theme,
+                        strings: strings,
+                        peer: nil,
+                        subject: .uniqueGift(gift: gift, price: nil),
+                        mode: .thumbnail
+                    )
+                )),
+                toComponent: AnyComponentWithIdentity(id: "user", component: AnyComponent(
+                    AvatarComponent(
+                        context: context,
+                        theme: presentationData.theme,
+                        peer: previousPeer
+                    )
+                )),
+                type: .take
+            )
+        )
+    ))
+    content.append(AnyComponentWithIdentity(
+        id: "text",
+        component: AnyComponent(
+            AlertTextComponent(content: .plain(strings.Conversation_Theme_GiftTransfer_Text(previousPeer.compactDisplayTitle).string))
+        )
+    ))
     
-    let controller = AlertController(theme: AlertControllerTheme(presentationData: presentationData), contentNode: contentNode!)
-    dismissImpl = { [weak controller] animated in
-        if animated {
-            controller?.dismissAnimated()
-        } else {
-            controller?.dismiss()
-        }
-    }
-    return controller
+    let alertController = AlertScreen(
+        context: context,
+        content: content,
+        actions: [
+            .init(title: strings.Common_Cancel),
+            .init(title: strings.Conversation_Theme_GiftTransfer_Proceed, type: .default, action: {
+                commit()
+            })
+        ]
+    )
+    return alertController
 }