Spellchecking (#6057)

Author: martinbonnin

.gitignore

@@ -7,6 +7,7 @@
 !**/.idea/icon.png
 !**/.idea/runConfigurations
 !**/.idea/scopes
+!**/.idea/dictionaries
 *.iml
 
 # Generated files

.idea/dictionaries/mbonnin.xml

@@ -4,7 +4,7 @@ The Apollo team welcomes contributions of all kinds, including bug reports, docu
 features.
 
 If you want to discuss the project or just say hi, stop
-by [the kotlinlang slack channel](https://app.slack.com/client/T09229ZC6/C01A6KM1SBZ)(get your
+by [the kotlinlang Slack channel](https://app.slack.com/client/T09229ZC6/C01A6KM1SBZ)(get your
 invite [here](https://slack.kotl.in/))
 
 ## Project Setup
@@ -154,7 +154,7 @@ Misc
 
 ## Workflow
 
-We love Github issues!  Before working on any new features, please open an issue so that we can agree on the direction,
+We love GitHub issues!  Before working on any new features, please open an issue so that we can agree on the direction,
 and hopefully avoid investing a lot of time on a feature that might need reworking.
 
 Small pull requests for things like typos, bugfixes, etc are always welcome.

CONTRIBUTING.md

@@ -89,7 +89,7 @@ If your user logged out, you might want to consider creating a new `ApolloClient
 
 </Note>
 
-Sometimes the websocket will emit an error that you can use in `webSocketReopenWhen` to create a new WebSocket. Other times that information will come from elsewhere in your app and you will have to force disconnect the WebSocket.
+Sometimes the websocket will emit an error that you can use in `webSocketReopenWhen` to create a new WebSocket. Other times that information will come from elsewhere in your app, and you have to force disconnect the WebSocket.
 
 First define your own Exception:
 

docs/source/advanced/authentication.mdx

@@ -2,7 +2,7 @@
 title: Client Awareness
 ---
 
-GraphOS Studio users can opt-in [Client Awareness](https://www.apollographql.com/docs/graphos/metrics/client-awareness/). Client Awareness allows you to view operation metrics split per client, helping you understand how each one interacts with your graph.
+GraphOS Studio users can opt in [Client Awareness](https://www.apollographql.com/docs/graphos/metrics/client-awareness/). Client Awareness allows you to view operation metrics split per client, helping you understand how each one interacts with your graph.
 
 Client Awareness uses `apollographql-client-name` and `apollographql-client-version` custom HTTP headers to report client usage.
 

docs/source/advanced/client-awareness.mdx

@@ -20,7 +20,7 @@ Starting with 4.0.0, Apollo Kotlin provides a new `com.apollographql.apollo.netw
 The `com.apollographql.apollo.network.websocket` implementation provides the following:
 
 1. Defaults to the [graphql-ws](https://github.com/enisdenjo/graphql-ws/blob/master/PROTOCOL.md) protocol, which has become the de facto standard. Using the other protocols is still possible but having a main, specified, protocol ensures we can write a good and solid test suite.
-2. Does not inherit from the old memory model design, making the code considerably simpler. In particular, `WebSocketEngine` is now event based and no attempt at flow control is done. If you buffers grow too much, your subscription fails.
+2. Does not inherit from the old memory model design, making the code considerably simpler. In particular, `WebSocketEngine` is now event based and no attempt at flow control is done. If your buffers grow too much, your subscription fails.
 3. Plays nicely with the ApolloClient `retryOnError` API.
 4. Handles different Subscription transports more consistently.
 

docs/source/advanced/experimental-websockets.mdx

@@ -4,11 +4,11 @@ title: Using a custom HTTP client
 
 By default, Apollo Kotlin uses the following HTTP clients for different platforms/languages:
 
-| Platform        | HTTP Client                                                                                                                                                                  |
-|-----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| Android/JVM     | [OkHttp](https://square.github.io/okhttp/)                                                                                                                                   |
+| Platform        | HTTP Client                                                                                                                                                                 |
+|-----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Android/JVM     | [OkHttp](https://square.github.io/okhttp/)                                                                                                                                  |
 | JavaScript/Wasm | [fetch()](https://developer.mozilla.org/en-US/docs/Web/API/fetch) / [Node Fetch](https://www.npmjs.com/package/node-fetch) for HTTP, [Ktor](https://ktor.io/) for WebSockets |
-| iOS/MacOS       | [NSURLSesssion](https://developer.apple.com/documentation/foundation/nsurlsession)                                                                                           |
+| iOS/MacOS       | [NSURLSession](https://developer.apple.com/documentation/foundation/nsurlsession)                                                                                           |
 
 ## Implement your own HTTP engine
 

docs/source/advanced/http-engine.mdx

@@ -6,7 +6,7 @@ title: Interceptors
 
 ### Apollo HTTP interceptors
 
-Apollo Kotlin supports multi platform `HttpInterceptor` very similar to `OkHttp` `Interceptors`. Use them to add authentication headers, log the network calls or anything else.
+Apollo Kotlin supports multi-platform `HttpInterceptor` very similar to `OkHttp` `Interceptors`. Use them to add authentication headers, log the network calls or anything else.
 
 The interface is a single method. For an example, implementing an authentication interceptors can be done with:
 
@@ -31,7 +31,7 @@ Apollo Kotlin comes bundled with [`ClientAwarenessInterceptor`](./client-awarene
 
 ### OkHttp interceptors
 
-If your project is an Android or JVM only project and you already have an [`OkHttp` `Interceptor`](https://square.github.io/okhttp/features/interceptors/), you can also reuse it:
+If your project is an Android or JVM only project, and you already have an [`OkHttp` `Interceptor`](https://square.github.io/okhttp/features/interceptors/), you can also reuse it:
 
 ```kotlin
 val okHttpClient = OkHttpClient.Builder()

docs/source/advanced/interceptors-http.mdx

@@ -7,7 +7,7 @@ Kotlin down to Javascript. `apollo-runtime` supports Kotlin/JS out of the box wi
 
 With that said, the default implementation has some performance limitations. Kotlin/JS adds a significant
 amount of overhead to basic Kotlin data structures (notably `List`, `Set`, and `Map`), and so performance sensitive
-workloads (like those found in the Kotlin JSON parsing codepaths) can be slow.
+workloads (like those found in the Kotlin JSON parsing code paths) can be slow.
 
 To work around this, Apollo Kotlin provides two alternative solutions to work with JS faster:
 
@@ -170,7 +170,7 @@ public interface Animal {
 ```
 
 Unfortunately, `@JsExport` does not support companion objects nor extension functions (see [limitations](#limitations)).
-What's more, `@JsExport` has no runtime type information from JS so it's impossible to tell at runtime if a given
+What's more, `@JsExport` has no runtime type information from JS, so it's impossible to tell at runtime if a given
 instance is a `Cat` or a `Lion`. To check this, use `__typename` and `apolloUnsafeCast`:
 
 ```kotlin
@@ -191,23 +191,23 @@ when (animal.__typename) {
 * `@JsExport` is an experimental feature in Kotlin and Apollo Kotlin and may change in future versions.
 * `@JsExport` only makes sense on response based codegen since it requires the Kotlin models to have the same shape as
   the JSON.
-* On JS, is is not possible to check if a `@JsExport` instance implements a given class. If you need polymorphism, you
+* On JS, it is not possible to check if a `@JsExport` instance implements a given class. If you need polymorphism, you
   must check `__typename` to determine what interface to use.
 * Extension functions on generated code break when you use this technique since we are casting a raw JS object and not
   actually instantiating a class.
 * `generateAsInternal = true` does not work with `@JsExport`, since the compiler ends up giving the internal modifier
   precedence, and thus mangling the property names.
 * Custom adapters can only be used when their target types are supported by JS (see the full list
   of [supported types](https://kotlinlang.org/docs/js-to-kotlin-interop.html#kotlin-types-in-javascript)).
-* Enums do not support `@JsExport` and are generated as `String`. The Kotlin enum is still generated so you can
+* Enums do not support `@JsExport` and are generated as `String`. The Kotlin enum is still generated, so you can
   use `safeValueOf()` to get a Kotlin enum from a `String`
 
 ## `DynamicJsJsonReader`
 
-If you would prefer to use `operationBased` models, and performance is not _as_ critical, you can
+If you prefer to use `operationBased` models, and performance is not _as_ critical, you can
 use `DynamicJsJsonReader`. `DynamicJsJsonReader` works with a JavaScript object that is already parsed on the JS side.
 
-In JS reading response byte by byte from a byte array like Okio does incurs a lot of overhead because Kotlin
+In JS reading response byte by byte from a byte array like Okio incurs a lot of overhead because Kotlin
 uses `Long` indices in its Arrays, and Longs do not have a JS implementation. 
 
 By bypassing this reading, `DynamicJsJsonReader` allows faster reading of responses while still keeping the full Kotlin type information. 
@@ -235,7 +235,7 @@ actual suspend fun <D : Operation.Data> JsonHttpClient.executeApolloOperation(
 
 ## Benchmarks
 
-We have done some benchmarking using a large polymorphic query result from the Github API.
+We have done some benchmarking using a large polymorphic query result from the GitHub API.
 
 The idea was to compare:
 

docs/source/advanced/js-interop.mdx

@@ -2,7 +2,7 @@
 title: Using the models without apollo-runtime
 ---
 
-`apollo-runtime` and `ApolloClient` provide support for doing the network requests and interacting with the cache but you can use the generated models and parsers without the runtime and use your network layer of choice for the HTTP calls.
+`apollo-runtime` and `ApolloClient` provide support for doing the network requests and interacting with the cache, but you can use the generated models and parsers without the runtime and use your network layer of choice for the HTTP calls.
 
 For this, remove the `com.apollographql.apollo:apollo-runtime` dependency and replace it with:
 
@@ -46,6 +46,7 @@ To parse a network response into the type safe models, use `parseJsonResponse`:
 ```kotlin
 /**
  * jsonResponse should contain a json with data and possibly errors:
+ * 
  * {
  *  "data": ...
  *  "errors": ...