Collection types support obtaining a PathObject with a fully-qualified string path, which is evaluated from the current path. Using this method loses rich compile-time type information.
A fully-qualified path string to navigate to, relative to the current path.
A PathObject for the specified path.
Batch multiple operations together using a batch context, which wraps the underlying PathObject or Instance from which the batch was called. The batch context always contains a resolved instance, even when called from a PathObject. If an instance cannot be resolved from the referenced path, or if the instance is not a LiveObject, this method throws an error.
Batching enables you to group multiple operations together and send them to the Ably service in a single channel message. As a result, other clients will receive the changes in a single channel message once the batch function has completed.
The objects' data is not modified inside the batch function. Instead, the objects will be updated when the batched operations are applied by the Ably service and echoed back to the client.
A synchronous function that receives a BatchContext used to group operations together.
A promise which resolves upon success of the batch operation and rejects with an ErrorInfo object upon its failure.
Get an in-memory JavaScript object representation of the map at this path.
Cyclic references are handled through memoization, returning shared compacted
object references for previously visited objects. This means the value returned
from compact() cannot be directly JSON-stringified if the object may contain cycles.
If the path does not resolve to any specific instance, returns undefined.
Use compactJson() for a JSON-serializable representation.
Get a JSON-serializable representation of the map at this path.
Binary values are converted to base64-encoded strings.
Cyclic references are represented as { objectId: string } instead of in-memory pointers,
making the result safe to pass to JSON.stringify().
If the path does not resolve to any specific instance, returns undefined.
Use compact() for an in-memory representation.
Returns an iterable of key-value pairs for each entry in the map at this path. Each value is represented as a PathObject corresponding to its key.
If the path does not resolve to a map object, returns an empty iterator.
Navigate to a child path within the map by obtaining a PathObject for that path. The next path segment in a LiveMap is identified with a string key.
A string key for the next path segment within the map.
A PathObject for the specified key.
Get the specific map instance currently at this path.
If the path does not resolve to any specific instance, returns undefined.
The LiveMapInstance at this path, or undefined if none exists.
Sends an operation to the Ably system to remove a key from a given LiveMapInstance, or from the map instance resolved from the path when using LiveMapPathObject.
If called via LiveMapInstance and the underlying instance at runtime is not a map, or if called via LiveMapPathObject and the map instance at the specified path cannot be resolved at the time of the call, this method throws an error.
This does not modify the underlying data of the map. Instead, the change is applied when the published operation is echoed back to the client and applied to the object. To get notified when object gets updated, use PathObject.subscribe or Instance.subscribe, as appropriate.
The key to remove.
A promise which resolves upon success of the operation and rejects with an ErrorInfo object upon its failure.
Sends an operation to the Ably system to set a key to a specified value on a given LiveMapInstance, or on the map instance resolved from the path when using LiveMapPathObject.
If called via LiveMapInstance and the underlying instance at runtime is not a map, or if called via LiveMapPathObject and the map instance at the specified path cannot be resolved at the time of the call, this method throws an error.
This does not modify the underlying data of the map. Instead, the change is applied when the published operation is echoed back to the client and applied to the object. To get notified when object gets updated, use PathObject.subscribe or Instance.subscribe, as appropriate.
The key to set the value for.
The value to assign to the key.
A promise which resolves upon success of the operation and rejects with an ErrorInfo object upon its failure.
Registers a listener that is called each time the object or a primitive value at this path is updated.
The provided listener receives a PathObject representing the path at which there was an object change, and, if applicable, an ObjectMessage that carried the operation that led to the change.
By default, subscriptions observe nested changes, but you can configure the observation depth
using the options parameter.
A PathObject subscription observes whichever value currently exists at this path. The subscription remains active even if the path temporarily does not resolve to any value (for example, if an entry is removed from a map). If the object instance at this path changes, the subscription automatically switches to observe the new instance and stops observing the old one.
An event listener function.
Optional options: PathObjectSubscriptionOptions
Optional subscription configuration.
A Subscription object that allows the provided listener to be deregistered from future updates.
Registers a subscription listener and returns an async iterator that yields subscription events each time the object or a primitive value at this path is updated.
This method functions in the same way as the regular PathObject.subscribe() method,
but instead returns an async iterator that can be used in a for await...of loop for convenience.
Optional options: PathObjectSubscriptionOptions
Optional subscription configuration.
An async iterator that yields PathObjectSubscriptionEvent objects.
Returns an iterable of values in the map at this path. Each value is represented as a PathObject.
If the path does not resolve to a map object, returns an empty iterator.
Generated using TypeDoc
A PathObject representing a LiveMap instance at a specific path. The type parameter T describes the expected structure of the map's entries.