Updated the docs

Author: martinmitrevski

docusaurus/docs/iOS/advanced/assertions.md

@@ -0,0 +1,26 @@
+---
+title: Assertions
+---
+
+A common way of highlighting unexpected behaviors in Swift is by using [assertions](https://developer.apple.com/documentation/swift/1541112-assert). 
+
+Inside the Stream SDKs, we use wrappers around it (`log.assert`/`log.assertionFailure`). This is because we want to allow the integrators to silence those if they want to.
+
+You can change that behavior by changing the value for `assertionsEnabled` as follows:
+
+```
+StreamRuntimeCheck.assertionsEnabled = true
+```
+
+The default value for this property is `false`
+
+Independently of the value of this flag, a message will always be printed in the console.
+
+:::note
+When enabling Stream assertions, the default behavior of assertions still apply:
+- In playgrounds and -Onone builds (the default for Xcode’s Debug configuration): If the condition evaluates to false, stop program execution in a debuggable state after printing the message.
+- In -O builds (the default for Xcode’s Release configuration), the condition is not evaluated, and there are no effects.
+- In -Ounchecked builds, the condition is not evaluated, but the optimizer may assume that it always evaluates to true. Failure to satisfy that assumption is a serious programming error.
+
+Read more [here](https://developer.apple.com/documentation/swift/1541112-assert). 
+:::

docusaurus/docs/iOS/common-content/components-note.md

@@ -1,3 +1,3 @@
 :::note
-You can find more information on how the components configuration works [here](../uikit/components/custom-components.md).
+You can find more information on how the components configuration works [here](../uikit/custom-components.md).
 :::

docusaurus/docs/iOS/common-content/reference-docs/stream-chat/api-client/endpoints/payloads/channel-config-properties.md

@@ -47,6 +47,14 @@ Enables message thread replies. Enabled by default.
 public let repliesEnabled: Bool
 ```
 
+### `quotesEnabled`
+
+Enables quoting of messages. Enabled by default.
+
+``` swift
+public let quotesEnabled: Bool
+```
+
 ### `searchEnabled`
 
 Controls if messages should be searchable (this is a premium feature). Disabled by default.

docusaurus/docs/iOS/common-content/reference-docs/stream-chat/controllers/channel-controller/chat-channel-controller-properties.md

@@ -135,6 +135,14 @@ var areReactionsEnabled: Bool
 var areRepliesEnabled: Bool 
 ```
 
+### `areQuotesEnabled`
+
+`true` if the channel has quotes enabled. Defaults to `false` if the channel doesn't exist yet.
+
+``` swift
+var areQuotesEnabled: Bool 
+```
+
 ### `areReadEventsEnabled`
 
 `true` if the channel has read events enabled. Defaults to `false` if the channel doesn't exist yet.

docusaurus/docs/iOS/guides/offline-support.md

@@ -0,0 +1,56 @@
+---
+title: Offline Support
+---
+
+Offline support comes in 4 different aspects:
+
+- Connection Recovery
+- Events Recovery
+- Queue Offline Actions (optional, enabled by default)
+- Keeping the DB on disk (optional, enabled by default)
+
+### Connection Recovery:
+
+It is really important to make sure that the app properly reconnects after a downtime, independently of what was the cause of it. It can happen that you backgrounded the app, you lost connection or maybe it was killed by yourself or the system.
+
+We are listening to the app's lifecycle to make sure we perform the right set of actions to bring you up online as soon as possible
+
+
+### Events Recovery:
+
+Whenever the app is not foregrounded and connected to the internet, there are likely other actions performed by other users. Especially in a Chat app, there are tons of events that can happen while you were offline.
+
+To overcome this situation, we are fetching all the events that happened since the end of your last online session up until the moment you foreground the app, we are processing them and making sure the app accordingly reflects those.
+
+This happens without you needing to do anything.
+
+
+### Queued Offline Actions:
+
+You may be in the subway, and you are trying to send a message, but suddenly your connection drops. We make sure that this action is queued, and sent whenever you come back offline.
+Even if you/the system kills the app, we make sure the request is sent in your next session.
+
+These are the actions that support offline queuing:
+- Send message
+- Edit message
+- Delete message
+- Add reaction
+- Delete reaction
+
+### Keeping the DB on disk
+
+By making sure that the DB stays on disk, we can guarantee that the data stays across sessions. This helps when it comes to perception. Having fewer loading states or blank pages is more engaging to the users.
+
+
+## Opting out
+
+As mentioned above, you can opt-out for:
+- Queue Offline Actions
+- Keeping the DB on disk
+
+To do that, you can just modify your configuration as follows:
+
+```swift
+var config = ChatClientConfig(apiKey: .init("<# Your API Key Here #>"))        
+config.isLocalStorageEnabled = false
+```

docusaurus/docs/iOS/guides/push-notifications.md

@@ -5,7 +5,7 @@ title: Push Notifications
 Push notifications can be configured to receive updates when the application is closed or on the background. Stream Chat sends push notification to channel members that are not online and have at least one registered device. Stream supports both **Certificate-based provider connection trust (.p12 certificate)** and **Token-based provider connection trust (JWT)**. Token-based authentication is the preferred way to configure push notifications. 
 
 :::note
-You can find more on setting up push [here](https://getstream.io/chat/docs/php/push_ios/?language=swift). Make sure you've taken care of authentication before proceeding to the next steps.
+You can find more on setting up push [here](https://getstream.io/chat/docs/ios-swift/push_introduction/?language=swift). Make sure you've taken care of authentication before proceeding to the next steps.
 :::
 
 ### Setup

docusaurus/docs/iOS/guides/working-with-attachments.md

@@ -93,11 +93,12 @@ Components.default.filesAttachmentInjector = MyCustomAttachmentViewInjector.self
 Stream chat allows you to create your own types of attachments as well. The steps to follow to add support for a custom attachment type are the following:
 
 1. Extend `AttachmentType` to include the custom type
-1. Create a new AttachmentPayload struct to handle your custom attachment data
-1. Create a new AttachmentViewInjector 
+1. Create a new `AttachmentPayload` struct to handle your custom attachment data
+1. Create a typealias for `ChatMessageAttachment<AttachmentPayload>` which will be used for the content of the view
+1. Create a new `AttachmentViewInjector`
 1. Configure the SDK to use your view injector class to render custom attachments
 
-Let's assume we want to attach a workout session to a message, the payload of the attachment will looks like this:
+Let's assume we want to attach a workout session to a message, the payload of the attachment will look like this:
 
 
 ```json
@@ -111,13 +112,15 @@ Let's assume we want to attach a workout session to a message, the payload of th
 }
 ```
 
-Here's how we get around the first two steps:
+Here's how we get around the first three steps:
 
 ```swift
 public extension AttachmentType {
     static let workout = Self(rawValue: "workout")
 }
 
+public typealias ChatMessageWorkoutAttachment = ChatMessageAttachment<WorkoutAttachmentPayload>
+
 public struct WorkoutAttachmentPayload: AttachmentPayload {
     public static var type: AttachmentType = .workout
 

docusaurus/docs/iOS/swiftui/components/message-list.md

@@ -8,9 +8,43 @@ The message list view in the SwiftUI SDK allows several customization options. T
 
 If you are developing an app with this use-case, you can customize the [message avatars](../custom-avatar), [reactions](../message-reactions), [theming and presentation logic](../../getting-started) and the different types of [attachments](../attachments).
 
+## Directly Showing Channel View
+
+In some cases, you want to show directly the channel view, without having a channel list as the previous screen. Here's an example how to show the channel view as an initial screen, with a predefined channel:
+
+```swift
+@main
+struct TestStreamSDKApp: App {
+    
+    @Injected(\.chatClient) var chatClient
+    
+    @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
+            
+    var body: some Scene {
+        WindowGroup {
+            ChatChannelView(
+                viewFactory: DefaultViewFactory.shared,
+                channelController: controller
+            )
+        }
+
+    }
+    
+    private var controller: ChatChannelController {
+        let controller = chatClient.channelController(
+            for: try! ChannelId(cid: "messaging:0D991C91-2"),
+           messageOrdering: .topToBottom
+        )
+        
+        return controller
+    }
+    
+}
+``` 
+
 ## Message List Configuration
 
-Additionally, you can control the display of the helper views around the message (date indicators, avatars) and paddings, via the `MessageListConfig`'s properties `MessageDisplayOptions` and `MessagePaddings`. The `MessageListConfig` is part of the `Utils` class in `StreamChat`. Here's an example on how to hide the date indicators and avatars, while also increasing the horizontal padding.
+You can control the display of the helper views around the message (date indicators, avatars) and paddings, via the `MessageListConfig`'s properties `MessageDisplayOptions` and `MessagePaddings`. The `MessageListConfig` is part of the `Utils` class in `StreamChat`. Here's an example on how to hide the date indicators and avatars, while also increasing the horizontal padding.
 
 ```swift
 let messageDisplayOptions = MessageDisplayOptions(showAvatars: false, showMessageDate: false)
@@ -26,6 +60,29 @@ let utils = Utils(messageListConfig: messageListConfig)
 streamChat = StreamChat(chatClient: chatClient, utils: utils)
 ```
 
+Other config options you can enable or disable via the `MessageListConfig` are:
+- `messagePopoverEnabled` - the default value is true. If set to false, it will disable the message popover.
+- `doubleTapOverlayEnabled` - the default value is false. If set to true, you can show the message popover also with double tap.
+- `becomesFirstResponderOnOpen` - the default value is false. If set to true, the channel will open the keyboard on view appearance.
+
+With the `MessageDisplayOptions`, you can also customize the transitions applied to the message views. The default message view transition in the SDK is `identity`. You can use the other default ones, such as `scale`, `opacity` and `slide`, or you can create your own custom transitions. Here's an example how to do this:
+
+```swift
+var customTransition: AnyTransition {
+    .scale.combined(with:
+        AnyTransition.asymmetric(
+            insertion: .move(edge: .trailing),
+            removal: .move(edge: .leading)
+        )
+    )
+}
+
+let messageDisplayOptions = MessageDisplayOptions(
+    currentUserMessageTransition: customTransition,
+    otherUserMessageTransition: customTransition
+)
+```
+
 You can also modify the background of the message list to any SwiftUI `View` (`Color`, `LinearGradient`, `Image` etc.). In order to do this, you would need to implement the `makeMessageListBackground` method in the `ViewFactory`.
 
 ```swift

docusaurus/docs/iOS/swiftui/components/message-reactions.md

@@ -24,6 +24,19 @@ let appearance = Appearance(images: images)
 streamChat = StreamChat(chatClient: chatClient, appearance: appearance)
 ```
 
+You can also change the tint color of the reactions, by changing `reactionCurrentUserColor` for the current user's reactions, or `reactionOtherUserColor` for other users' reactions. Additionally, you can set a background for a selected reaction, with `selectedReactionBackgroundColor`. These colors are optional, so if you don't want to tint the reactions, but want to use the original icon color, you can just pass `nil` as a value. Here's an example how to change these values:
+
+```swift
+var colors = ColorPalette()
+colors.reactionCurrentUserColor = UIColor.blue
+colors.reactionOtherUserColor = UIColor.red
+colors.selectedReactionBackgroundColor = UIColor.gray
+        
+let appearance = Appearance(colors: colors)
+        
+streamChat = StreamChat(chatClient: chatClient, appearance: appearance)
+```
+
 ## Changing the Message Reactions View
 
 Alternatively, you can completely swap the `ReactionsContainer` view with your own implementation. In order to do that, you need to implement the `makeMessageReactionView` method from the `ViewFactory`, which is called with the message as a parameter. 

docusaurus/docs/iOS/swiftui/dependency-injection.md

@@ -0,0 +1,53 @@
+---
+title: Dependency Injection
+---
+
+For injecting dependencies in the SwiftUI SDK, we are using an approach based on [this article](https://www.avanderlee.com/swift/dependency-injection/). It works similarly to the @Environment in SwiftUI, but it also allows access to the dependencies in non-view related code.
+
+When you initialize the SDK (by creating the `StreamChat` object), all the dependencies are created too, and you can use them anywhere in your code. In order to access a particular type, you need to use the `@Injected(\.keyPath)` property wrapper:
+
+```swift
+@Injected(\.chatClient) var chatClient
+@Injected(\.fonts) var fonts
+@Injected(\.colors) var colors
+@Injected(\.images) var images
+@Injected(\.utils) var utils
+```
+
+### Extending the DI with Custom Types
+
+In some cases, you might also need to extend our DI mechanism with your own types. For example, you may want to be able to access your custom types like this:
+
+```swift
+@Injected(\.customType) var customType
+```  
+
+In order to achieve this, you first need to define your own `InjectionKey`, and define it's currentValue, which basically creates the new instance of your type.
+
+```swift
+class CustomType {
+	// your custom logic here
+}
+
+struct CustomInjectionKey: InjectionKey {
+    static var currentValue: CustomType = CustomType()
+}
+```
+
+Next, you need to extend our `InjectedValues` with your own custom type, by defining its getter and setter.
+
+```swift
+extension InjectedValues {
+    /// Provides access to the `CustomType` instance in the views and view models.
+    var customType: CustomType {
+        get {
+            Self[CustomInjectionKey.self]
+        }
+        set {
+            Self[CustomInjectionKey.self] = newValue
+        }
+    }
+}
+```
+
+With these few simple steps, you can now access your custom functionality in both your app code and in your custom implementations of the views used throughout the SDK.