Interface ClientExtras

Hierarchy

  • ClientExtras

Properties

addCacheHelpers addNonParentCacheHelpers applicationCache cacheFromWatch channelsCache debug$ directMessagesCache dispatch$ emojisCache fromDispatch fromDispatchWithShard gateway guildsCache invitesCache latestDispatch membersCache messagesCache nonParentCacheFromWatch onlyWithCacheResults rateLimit rolesCache stageInstancesCache withCaches

Properties

addCacheHelpers

addCacheHelpers: (<T, S>(store: S) => S & CacheStoreHelpers<T>)

Type declaration

    • <T, S>(store: S): S & CacheStoreHelpers<T>

    • Add cache helpers to a cache store

      Type Parameters

      • T

      • S extends AnyCacheStore<T>

      Parameters

      • store: S

      Returns S & CacheStoreHelpers<T>

addNonParentCacheHelpers

addNonParentCacheHelpers: (<T, S>(store: S) => S & NonParentCacheStoreHelpers<T>)

Type declaration

    • <T, S>(store: S): S & NonParentCacheStoreHelpers<T>

    • Add cache helpers to a non parent cache store

      Type Parameters

      • T

      • S extends AnyNonParentStore<T>

      Parameters

      • store: S

      Returns S & NonParentCacheStoreHelpers<T>

applicationCache

applicationCache: NonParentCacheStoreFactory<Application>

Cache of the latest application

cacheFromWatch

cacheFromWatch: (<T>(watch$: Observable<WatchOp<T>>) => CacheStoreFactory<T>)

Type declaration

    • <T>(watch$: Observable<WatchOp<T>>): CacheStoreFactory<T>

    • Create your own cache store from a watcher observable

      Type Parameters

      • T

      Parameters

      • watch$: Observable<WatchOp<T>>

      Returns CacheStoreFactory<T>

channelsCache

channelsCache: CacheStoreFactory<Channel>

Cache of the latest channels for each guild

debug$

debug$: Observable<never>

Subscribe to this observable to enable debug logging

directMessagesCache

directMessagesCache: NonParentCacheStoreFactory<Message>

Cache of the latest direct messages for each guild

dispatch$

dispatch$: Observable<GatewayPayload<ReceiveEvent>>

Observable of all the dispatch events

emojisCache

emojisCache: CacheStoreFactory<Emoji>

Cache of the latest emojis for each guild

fromDispatch

fromDispatch: Dispatch

Helper function to listen to an individual dispatch event

fromDispatchWithShard

fromDispatchWithShard: DispatchWithShard

Helper function to listen to an individual dispatch event, along with the shard

gateway

gateway: {
    debug$: Observable<never>;
    dispatch$: Observable<GatewayPayload<ReceiveEvent>>;
    fromDispatch: Dispatch;
    fromDispatchWithShard: DispatchWithShard;
    latestDispatch: Dispatch;
    raw$: Observable<GatewayPayload<any>>;
    shards$: Observable<{
        conn: {
            dispatch$: Observable<GatewayPayload<ReceiveEvent>>;
            heartbeat$: Observable<GatewayPayload<Heartbeat>>;
            heartbeatAck$: Observable<GatewayPayload<undefined>>;
            hello$: Observable<GatewayPayload<HelloEvent>>;
            invalidSession$: Observable<GatewayPayload<boolean>>;
            raw$: Observable<GatewayPayload<any>>;
            reconnect$: Observable<GatewayPayload<any>>;
            setBaseUrl: ((baseUrl: string) => void);
        };
        debug$: Observable<never>;
        dispatch$: Observable<GatewayPayload<ReceiveEvent>>;
        effects$: Observable<never>;
        id: [number, number];
        latency$: Observable<number>;
        raw$: Observable<GatewayPayload<any>>;
        ready$: Observable<Option<ReadyEvent>>;
        reconnect: (() => void);
        send: ((payload: GatewayPayload<any>) => void);
    }>;
    shardsReady$: Observable<void>;
}

Type declaration

guildsCache

guildsCache: NonParentCacheStoreFactory<Guild>

Cache of the latest guilds

invitesCache

invitesCache: CacheStoreFactory<PartialInvite>

Cache of the latest invites for each guild

latestDispatch

latestDispatch: Dispatch

Helper function to listen to an individual dispatch event

membersCache

membersCache: CacheStoreFactory<GuildMember>

Cache of the latest members for each guild

messagesCache

messagesCache: CacheStoreFactory<Message>

Cache of the latest messages for each guild

nonParentCacheFromWatch

nonParentCacheFromWatch: (<T>(watch$: Observable<WatchOp<T>>) => NonParentCacheStoreFactory<T>)

Type declaration

    • <T>(watch$: Observable<WatchOp<T>>): NonParentCacheStoreFactory<T>

    • Create your own cache store with parent ids from a watcher observable

      Type Parameters

      • T

      Parameters

      • watch$: Observable<WatchOp<T>>

      Returns NonParentCacheStoreFactory<T>

onlyWithCacheResults

onlyWithCacheResults: (() => (<T, M>(source$: Observable<readonly [T, undefined | M]>) => Observable<readonly [T, M]>))

Type declaration

    • (): (<T, M>(source$: Observable<readonly [T, undefined | M]>) => Observable<readonly [T, M]>)

    • Use this operator in combination with withCaches. It will filter out any direct messages etc.

      client.dispatch$(Events.GuildMemberAdd).pipe(
        client.withCaches({
          roles: rolesCache,
        })(({ message }) => message.guild_id),
        client.onlyWithCacheResults(),
      );

      Returns (<T, M>(source$: Observable<readonly [T, undefined | M]>) => Observable<readonly [T, M]>)

        • <T, M>(source$: Observable<readonly [T, undefined | M]>): Observable<readonly [T, M]>

        • Type Parameters

          • T

          • M

          Parameters

          • source$: Observable<readonly [T, undefined | M]>

          Returns Observable<readonly [T, M]>

rateLimit

rateLimit: ((key: string, window: number, limit: number) => (<T>(source$: Observable<T>) => Observable<T>))

Type declaration

    • (key: string, window: number, limit: number): (<T>(source$: Observable<T>) => Observable<T>)

    • RxJS rate limit operator, which is backed by the store.

      Parameters

      • key: string
      • window: number
      • limit: number

      Returns (<T>(source$: Observable<T>) => Observable<T>)

        • <T>(source$: Observable<T>): Observable<T>

        • Type Parameters

          • T

          Parameters

          • source$: Observable<T>

          Returns Observable<T>

rolesCache

rolesCache: CacheStoreFactory<Role>

Cache of the latest roles for each guild

stageInstancesCache

stageInstancesCache: CacheStoreFactory<StageInstance>

Cache of the latest stageInstances for each guild

withCaches

withCaches: (<M>(stores: M) => (<T>(getParentId: ((resource: T) => undefined | `${bigint}`)) => ((source$: Observable<T>) => Observable<readonly [T, undefined | WithCachesResult<M>]>)))

Type declaration

    • <M>(stores: M): (<T>(getParentId: ((resource: T) => undefined | `${bigint}`)) => ((source$: Observable<T>) => Observable<readonly [T, undefined | WithCachesResult<M>]>))

    • RxJS operator that appends cached data to the stream. E.g.

      client.dispatch$("GUILD_MEMBER_ADD").pipe(
        client.withCaches({
          roles: rolesCache,
        })(({ message }) => message.guild_id),
      );

      Type Parameters

      • M extends {
            [key: string]: WithCachesFn<any>;
        }

      Parameters

      • stores: M

      Returns (<T>(getParentId: ((resource: T) => undefined | `${bigint}`)) => ((source$: Observable<T>) => Observable<readonly [T, undefined | WithCachesResult<M>]>))

        • <T>(getParentId: ((resource: T) => undefined | `${bigint}`)): ((source$: Observable<T>) => Observable<readonly [T, undefined | WithCachesResult<M>]>)

        • Type Parameters

          • T

          Parameters

          • getParentId: ((resource: T) => undefined | `${bigint}`)
              • (resource: T): undefined | `${bigint}`

              • Parameters

                • resource: T

                Returns undefined | `${bigint}`

          Returns ((source$: Observable<T>) => Observable<readonly [T, undefined | WithCachesResult<M>]>)

            • (source$: Observable<T>): Observable<readonly [T, undefined | WithCachesResult<M>]>

            • Parameters

              • source$: Observable<T>

              Returns Observable<readonly [T, undefined | WithCachesResult<M>]>

Settings

Member Visibility

Theme

Generated using TypeDoc