@sanity/comlink
Version:
A library for one-to-many cross-origin communication between Window contexts, built on the postMessage API.
1,549 lines (1,538 loc) • 247 kB
TypeScript
import {
ActionFunction,
ActorRef,
ActorRefFrom,
ActorRefFromLogic,
AnyActorLogic,
AnyActorRef,
AnyEventObject,
CallbackActorLogic,
ConditionalRequired,
DoneStateEvent,
EventObject,
GetConcreteByKey,
InputFrom,
IsNotNever,
MachineSnapshot,
MetaObject,
NonReducibleUnknown,
ObservableActorLogic,
RequiredActorOptions,
RequiredLogicInput,
StateMachine,
StateValue,
Values,
} from 'xstate'
/**
* @public
*/
export declare interface BufferAddedEmitEvent<TMessage extends Message> {
type: 'buffer.added'
message: TMessage
}
/**
* @public
*/
export declare interface BufferFlushedEmitEvent<TMessage extends Message> {
type: 'buffer.flushed'
messages: TMessage[]
}
/**
* @public
*/
export declare type ChannelInput = Omit<ConnectionInput, 'target' | 'targetOrigin'>
/**
* @public
*/
export declare interface ChannelInstance<TSends extends Message, TReceives extends Message> {
on: <
TType extends TReceives['type'],
TMessage extends Extract<
TReceives,
{
type: TType
}
>,
>(
type: TType,
handler: (data: TMessage['data']) => Promise<TMessage['response']> | TMessage['response'],
) => () => void
onInternalEvent: <
TType extends InternalEmitEvent<TSends, TReceives>['type'],
TEvent extends Extract<
InternalEmitEvent<TSends, TReceives>,
{
type: TType
}
>,
>(
type: TType,
handler: (event: TEvent) => void,
) => () => void
onStatus: (handler: (event: StatusEvent) => void) => void
post: <
TType extends TSends['type'],
TMessage extends Extract<
TSends,
{
type: TType
}
>,
>(
...params: (TMessage['data'] extends undefined ? [TType] : never) | [TType, TMessage['data']]
) => void
start: () => () => void
stop: () => void
}
/**
* @public
*/
export declare type Connection<
TSends extends Message = Message,
TReceives extends Message = Message,
> = {
actor: ConnectionActor<TSends, TReceives>
connect: () => void
disconnect: () => void
id: string
name: string
machine: ReturnType<typeof createConnectionMachine<TSends, TReceives>>
on: <
TType extends TReceives['type'],
TMessage extends Extract<
TReceives,
{
type: TType
}
>,
>(
type: TType,
handler: (data: TMessage['data']) => Promise<TMessage['response']> | TMessage['response'],
) => () => void
onStatus: (handler: (status: Status) => void, filter?: Status) => () => void
post: <
TType extends TSends['type'],
TMessage extends Extract<
TSends,
{
type: TType
}
>,
>(
...params: (TMessage['data'] extends undefined ? [TType] : never) | [TType, TMessage['data']]
) => void
setTarget: (target: MessageEventSource) => void
start: () => () => void
stop: () => void
target: MessageEventSource | undefined
}
/**
* @public
*/
export declare type ConnectionActor<
TSends extends Message,
TReceives extends Message,
> = ActorRefFrom<ReturnType<typeof createConnectionMachine<TSends, TReceives>>>
/**
* @public
*/
export declare type ConnectionActorLogic<
TSends extends Message,
TReceives extends Message,
> = ReturnType<typeof createConnectionMachine<TSends, TReceives>>
/**
* @public
*/
export declare interface ConnectionInput {
connectTo: string
domain?: string
heartbeat?: boolean
name: string
id?: string
target?: MessageEventSource
targetOrigin: string
}
/**
* @public
*/
export declare interface Controller {
addTarget: (target: MessageEventSource) => () => void
createChannel: <TSends extends Message, TReceives extends Message>(
input: ChannelInput,
machine?: ConnectionActorLogic<TSends, TReceives>,
) => ChannelInstance<TSends, TReceives>
destroy: () => void
}
/**
* @public
*/
export declare const createConnection: <TSends extends Message, TReceives extends Message>(
input: ConnectionInput,
machine?: ConnectionActorLogic<TSends, TReceives>,
) => Connection<TSends, TReceives>
/**
* @public
*/
export declare const createConnectionMachine: <
TSends extends Message,
TReceives extends Message,
TSendsWithoutResponse extends WithoutResponse<TSends> = WithoutResponse<TSends>,
>() => StateMachine<
{
buffer: Array<TSendsWithoutResponse>
channelId: string
connectTo: string
domain: string
heartbeat: boolean
id: string
name: string
requests: Array<RequestActorRef<TSends>>
target: MessageEventSource | undefined
targetOrigin: string
},
| {
type: 'connect'
}
| {
type: 'disconnect'
}
| {
type: 'message.received'
message: MessageEvent<ProtocolMessage<TReceives>>
}
| {
type: 'post'
data: TSendsWithoutResponse
}
| {
type: 'response'
respondTo: string
data: Pick<TSends, 'response'>
}
| {
type: 'request.aborted'
requestId: string
}
| {
type: 'request.failed'
requestId: string
}
| {
type: 'request.success'
requestId: string
response: TSends['response'] | null
responseTo: string | undefined
}
| {
type: 'request'
data: RequestData<TSends> | RequestData<TSends>[]
}
| {
type: 'syn'
}
| {
type: 'target.set'
target: MessageEventSource
},
{
[x: string]:
| ActorRefFromLogic<
StateMachine<
RequestMachineContext<TSends>,
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
},
{
'listen for response'?:
| ActorRefFromLogic<
ObservableActorLogic<
MessageEvent<ProtocolMessage<ResponseMessage>>,
{
requestId: string
sources: Set<MessageEventSource>
signal?: AbortSignal
},
EventObject
>
>
| undefined
},
{
src: 'listen'
logic: ObservableActorLogic<
MessageEvent<ProtocolMessage<ResponseMessage>>,
{
requestId: string
sources: Set<MessageEventSource>
signal?: AbortSignal
},
EventObject
>
id: 'listen for response'
},
Values<{
'send message': {
type: 'send message'
params: {
message: ProtocolMessage
}
}
'on success': {
type: 'on success'
params: NonReducibleUnknown
}
'on fail': {
type: 'on fail'
params: NonReducibleUnknown
}
'on abort': {
type: 'on abort'
params: NonReducibleUnknown
}
}>,
{
type: 'expectsResponse'
params: unknown
},
'initialTimeout' | 'responseTimeout',
'idle' | 'sending' | 'awaiting' | 'success' | 'aborted' | 'failed',
string,
{
channelId: string
data?: TSends['data'] | undefined
domain: string
expectResponse?: boolean
from: string
parentRef: AnyActorRef
resolvable?: PromiseWithResolvers<TSends['response']> | undefined
responseTimeout?: number
responseTo?: string
signal?: AbortSignal
sources: Set<MessageEventSource> | MessageEventSource
suppressWarnings?: boolean
targetOrigin: string
to: string
type: TSends['type']
},
{
requestId: string
response: TSends['response'] | null
responseTo: string | undefined
},
| {
type: 'request.failed'
requestId: string
}
| {
type: 'request.aborted'
requestId: string
}
| {
type: 'request.success'
requestId: string
response: MessageData | null
responseTo: string | undefined
},
MetaObject,
{
readonly context: ({
input,
}: {
spawn: {
<TSrc extends 'listen'>(
logic: TSrc,
...[options]: {
src: 'listen'
logic: ObservableActorLogic<
MessageEvent<ProtocolMessage<ResponseMessage>>,
{
requestId: string
sources: Set<MessageEventSource>
signal?: AbortSignal
},
EventObject
>
id: 'listen for response'
} extends infer T
? T extends {
src: 'listen'
logic: ObservableActorLogic<
MessageEvent<ProtocolMessage<ResponseMessage>>,
{
requestId: string
sources: Set<MessageEventSource>
signal?: AbortSignal
},
EventObject
>
id: 'listen for response'
}
? T extends {
src: TSrc
}
? ConditionalRequired<
[
options?:
| ({
id?: T['id'] | undefined
systemId?: string
input?: InputFrom<T['logic']> | undefined
syncSnapshot?: boolean
} & {[K in RequiredActorOptions<T>]: unknown})
| undefined,
],
IsNotNever<RequiredActorOptions<T>>
>
: never
: never
: never
): ActorRefFromLogic<
GetConcreteByKey<
{
src: 'listen'
logic: ObservableActorLogic<
MessageEvent<ProtocolMessage<ResponseMessage>>,
{
requestId: string
sources: Set<MessageEventSource>
signal?: AbortSignal
},
EventObject
>
id: 'listen for response'
},
'src',
TSrc
>['logic']
>
<TLogic extends AnyActorLogic>(
src: TLogic,
...[options]: ConditionalRequired<
[
options?:
| ({
id?: never
systemId?: string
input?: InputFrom<TLogic> | undefined
syncSnapshot?: boolean
} & {[K in RequiredLogicInput<TLogic>]: unknown})
| undefined,
],
IsNotNever<RequiredLogicInput<TLogic>>
>
): ActorRefFromLogic<TLogic>
}
input: {
channelId: string
data?: TSends['data'] | undefined
domain: string
expectResponse?: boolean
from: string
parentRef: AnyActorRef
resolvable?: PromiseWithResolvers<TSends['response']> | undefined
responseTimeout?: number
responseTo?: string
signal?: AbortSignal
sources: Set<MessageEventSource> | MessageEventSource
suppressWarnings?: boolean
targetOrigin: string
to: string
type: TSends['type']
}
self: ActorRef<
MachineSnapshot<
RequestMachineContext<TSends>,
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
},
Record<string, AnyActorRef | undefined>,
StateValue,
string,
unknown,
any,
any
>,
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
},
AnyEventObject
>
}) => {
channelId: string
data: TSends['data'] | undefined
domain: string
expectResponse: boolean
from: string
id: string
parentRef: AnyActorRef
resolvable: PromiseWithResolvers<TSends['response']> | undefined
response: null
responseTimeout: number | undefined
responseTo: string | undefined
signal: AbortSignal | undefined
sources: Set<MessageEventSource>
suppressWarnings: boolean | undefined
targetOrigin: string
to: string
type: TSends['type']
}
readonly initial: 'idle'
readonly on: {
readonly abort: '.aborted'
}
readonly states: {
readonly idle: {
readonly after: {
readonly initialTimeout: readonly [
{
readonly target: 'sending'
},
]
}
}
readonly sending: {
readonly entry: {
readonly type: 'send message'
readonly params: ({
context,
}: {
context: RequestMachineContext<TSends>
event:
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
}
}) => {
message: {
channelId: string
data: MessageData
domain: string
from: string
id: string
to: string
type: string
responseTo: string | undefined
}
}
}
readonly always: readonly [
{
readonly guard: 'expectsResponse'
readonly target: 'awaiting'
},
'success',
]
}
readonly awaiting: {
readonly invoke: {
readonly id: 'listen for response'
readonly src: 'listen'
readonly input: ({
context,
}: {
context: RequestMachineContext<TSends>
event:
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
}
self: ActorRef<
MachineSnapshot<
RequestMachineContext<TSends>,
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
},
Record<string, AnyActorRef>,
StateValue,
string,
unknown,
any,
any
>,
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
},
AnyEventObject
>
}) => {
requestId: string
sources: Set<MessageEventSource>
signal: AbortSignal | undefined
}
readonly onError: 'aborted'
}
readonly after: {
readonly responseTimeout: 'failed'
}
readonly on: {
readonly message: {
readonly actions: ActionFunction<
RequestMachineContext<TSends>,
{
type: 'message'
data: ProtocolMessage<ResponseMessage>
},
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
},
undefined,
{
src: 'listen'
logic: ObservableActorLogic<
MessageEvent<ProtocolMessage<ResponseMessage>>,
{
requestId: string
sources: Set<MessageEventSource>
signal?: AbortSignal
},
EventObject
>
id: 'listen for response'
},
never,
never,
never,
never
>
readonly target: 'success'
}
}
}
readonly failed: {
readonly type: 'final'
readonly entry: 'on fail'
}
readonly success: {
readonly type: 'final'
readonly entry: 'on success'
}
readonly aborted: {
readonly type: 'final'
readonly entry: 'on abort'
}
}
readonly output: ({
context,
self,
}: {
context: RequestMachineContext<TSends>
event: DoneStateEvent<unknown>
self: ActorRef<
MachineSnapshot<
RequestMachineContext<TSends>,
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
},
Record<string, AnyActorRef>,
StateValue,
string,
unknown,
any,
any
>,
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
},
AnyEventObject
>
}) => {
requestId: string
response: TSends['response'] | null
responseTo: string | undefined
}
}
>
>
| ActorRefFromLogic<
ObservableActorLogic<
{
type: string
message: MessageEvent<ProtocolMessage>
},
ListenInput,
EventObject
>
>
| ActorRefFromLogic<
CallbackActorLogic<
EventObject,
{
event: EventObject
immediate?: boolean
interval: number
},
EventObject
>
>
| undefined
'listen for handshake'?:
| ActorRefFromLogic<
ObservableActorLogic<
{
type: string
message: MessageEvent<ProtocolMessage>
},
ListenInput,
EventObject
>
>
| undefined
'listen for messages'?:
| ActorRefFromLogic<
ObservableActorLogic<
{
type: string
message: MessageEvent<ProtocolMessage>
},
ListenInput,
EventObject
>
>
| undefined
'send heartbeat'?:
| ActorRefFromLogic<
CallbackActorLogic<
EventObject,
{
event: EventObject
immediate?: boolean
interval: number
},
EventObject
>
>
| undefined
'send syn'?:
| ActorRefFromLogic<
CallbackActorLogic<
EventObject,
{
event: EventObject
immediate?: boolean
interval: number
},
EventObject
>
>
| undefined
},
Values<{
listen: {
src: 'listen'
logic: ObservableActorLogic<
{
type: string
message: MessageEvent<ProtocolMessage>
},
ListenInput,
EventObject
>
id: 'listen for handshake' | 'listen for messages'
}
sendBackAtInterval: {
src: 'sendBackAtInterval'
logic: CallbackActorLogic<
EventObject,
{
event: EventObject
immediate?: boolean
interval: number
},
EventObject
>
id: 'send heartbeat' | 'send syn'
}
requestMachine: {
src: 'requestMachine'
logic: StateMachine<
RequestMachineContext<TSends>,
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
},
{
'listen for response'?:
| ActorRefFromLogic<
ObservableActorLogic<
MessageEvent<ProtocolMessage<ResponseMessage>>,
{
requestId: string
sources: Set<MessageEventSource>
signal?: AbortSignal
},
EventObject
>
>
| undefined
},
{
src: 'listen'
logic: ObservableActorLogic<
MessageEvent<ProtocolMessage<ResponseMessage>>,
{
requestId: string
sources: Set<MessageEventSource>
signal?: AbortSignal
},
EventObject
>
id: 'listen for response'
},
Values<{
'send message': {
type: 'send message'
params: {
message: ProtocolMessage
}
}
'on success': {
type: 'on success'
params: NonReducibleUnknown
}
'on fail': {
type: 'on fail'
params: NonReducibleUnknown
}
'on abort': {
type: 'on abort'
params: NonReducibleUnknown
}
}>,
{
type: 'expectsResponse'
params: unknown
},
'initialTimeout' | 'responseTimeout',
'idle' | 'sending' | 'awaiting' | 'success' | 'aborted' | 'failed',
string,
{
channelId: string
data?: TSends['data'] | undefined
domain: string
expectResponse?: boolean
from: string
parentRef: AnyActorRef
resolvable?: PromiseWithResolvers<TSends['response']> | undefined
responseTimeout?: number
responseTo?: string
signal?: AbortSignal
sources: Set<MessageEventSource> | MessageEventSource
suppressWarnings?: boolean
targetOrigin: string
to: string
type: TSends['type']
},
{
requestId: string
response: TSends['response'] | null
responseTo: string | undefined
},
| {
type: 'request.failed'
requestId: string
}
| {
type: 'request.aborted'
requestId: string
}
| {
type: 'request.success'
requestId: string
response: MessageData | null
responseTo: string | undefined
},
MetaObject,
{
readonly context: ({
input,
}: {
spawn: {
<TSrc extends 'listen'>(
logic: TSrc,
...[options]: {
src: 'listen'
logic: ObservableActorLogic<
MessageEvent<ProtocolMessage<ResponseMessage>>,
{
requestId: string
sources: Set<MessageEventSource>
signal?: AbortSignal
},
EventObject
>
id: 'listen for response'
} extends infer T
? T extends {
src: 'listen'
logic: ObservableActorLogic<
MessageEvent<ProtocolMessage<ResponseMessage>>,
{
requestId: string
sources: Set<MessageEventSource>
signal?: AbortSignal
},
EventObject
>
id: 'listen for response'
}
? T extends {
src: TSrc
}
? ConditionalRequired<
[
options?:
| ({
id?: T['id'] | undefined
systemId?: string
input?: InputFrom<T['logic']> | undefined
syncSnapshot?: boolean
} & {[K in RequiredActorOptions<T>]: unknown})
| undefined,
],
IsNotNever<RequiredActorOptions<T>>
>
: never
: never
: never
): ActorRefFromLogic<
GetConcreteByKey<
{
src: 'listen'
logic: ObservableActorLogic<
MessageEvent<ProtocolMessage<ResponseMessage>>,
{
requestId: string
sources: Set<MessageEventSource>
signal?: AbortSignal
},
EventObject
>
id: 'listen for response'
},
'src',
TSrc
>['logic']
>
<TLogic extends AnyActorLogic>(
src: TLogic,
...[options]: ConditionalRequired<
[
options?:
| ({
id?: never
systemId?: string
input?: InputFrom<TLogic> | undefined
syncSnapshot?: boolean
} & {[K in RequiredLogicInput<TLogic>]: unknown})
| undefined,
],
IsNotNever<RequiredLogicInput<TLogic>>
>
): ActorRefFromLogic<TLogic>
}
input: {
channelId: string
data?: TSends['data'] | undefined
domain: string
expectResponse?: boolean
from: string
parentRef: AnyActorRef
resolvable?: PromiseWithResolvers<TSends['response']> | undefined
responseTimeout?: number
responseTo?: string
signal?: AbortSignal
sources: Set<MessageEventSource> | MessageEventSource
suppressWarnings?: boolean
targetOrigin: string
to: string
type: TSends['type']
}
self: ActorRef<
MachineSnapshot<
RequestMachineContext<TSends>,
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
},
Record<string, AnyActorRef | undefined>,
StateValue,
string,
unknown,
any,
any
>,
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
},
AnyEventObject
>
}) => {
channelId: string
data: TSends['data'] | undefined
domain: string
expectResponse: boolean
from: string
id: string
parentRef: AnyActorRef
resolvable: PromiseWithResolvers<TSends['response']> | undefined
response: null
responseTimeout: number | undefined
responseTo: string | undefined
signal: AbortSignal | undefined
sources: Set<MessageEventSource>
suppressWarnings: boolean | undefined
targetOrigin: string
to: string
type: TSends['type']
}
readonly initial: 'idle'
readonly on: {
readonly abort: '.aborted'
}
readonly states: {
readonly idle: {
readonly after: {
readonly initialTimeout: readonly [
{
readonly target: 'sending'
},
]
}
}
readonly sending: {
readonly entry: {
readonly type: 'send message'
readonly params: ({
context,
}: {
context: RequestMachineContext<TSends>
event:
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
}
}) => {
message: {
channelId: string
data: MessageData
domain: string
from: string
id: string
to: string
type: string
responseTo: string | undefined
}
}
}
readonly always: readonly [
{
readonly guard: 'expectsResponse'
readonly target: 'awaiting'
},
'success',
]
}
readonly awaiting: {
readonly invoke: {
readonly id: 'listen for response'
readonly src: 'listen'
readonly input: ({
context,
}: {
context: RequestMachineContext<TSends>
event:
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
}
self: ActorRef<
MachineSnapshot<
RequestMachineContext<TSends>,
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
},
Record<string, AnyActorRef>,
StateValue,
string,
unknown,
any,
any
>,
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
},
AnyEventObject
>
}) => {
requestId: string
sources: Set<MessageEventSource>
signal: AbortSignal | undefined
}
readonly onError: 'aborted'
}
readonly after: {
readonly responseTimeout: 'failed'
}
readonly on: {
readonly message: {
readonly actions: ActionFunction<
RequestMachineContext<TSends>,
{
type: 'message'
data: ProtocolMessage<ResponseMessage>
},
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
},
undefined,
{
src: 'listen'
logic: ObservableActorLogic<
MessageEvent<ProtocolMessage<ResponseMessage>>,
{
requestId: string
sources: Set<MessageEventSource>
signal?: AbortSignal
},
EventObject
>
id: 'listen for response'
},
never,
never,
never,
never
>
readonly target: 'success'
}
}
}
readonly failed: {
readonly type: 'final'
readonly entry: 'on fail'
}
readonly success: {
readonly type: 'final'
readonly entry: 'on success'
}
readonly aborted: {
readonly type: 'final'
readonly entry: 'on abort'
}
}
readonly output: ({
context,
self,
}: {
context: RequestMachineContext<TSends>
event: DoneStateEvent<unknown>
self: ActorRef<
MachineSnapshot<
RequestMachineContext<TSends>,
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
},
Record<string, AnyActorRef>,
StateValue,
string,
unknown,
any,
any
>,
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
},
AnyEventObject
>
}) => {
requestId: string
response: TSends['response'] | null
responseTo: string | undefined
}
}
>
id: string | undefined
}
}>,
Values<{
'buffer message': {
type: 'buffer message'
params: NonReducibleUnknown
}
'create request': {
type: 'create request'
params: NonReducibleUnknown
}
'emit received message': {
type: 'emit received message'
params: NonReducibleUnknown
}
'emit status': {
type: 'emit status'
params: {
status: Status
}
}
'post message': {
type: 'post message'
params: NonReducibleUnknown
}
'remove request': {
type: 'remove request'
params: NonReducibleUnknown
}
'respond': {
type: 'respond'
params: NonReducibleUnknown
}
'send handshake ack': {
type: 'send handshake ack'
params: NonReducibleUnknown
}
'send disconnect': {
type: 'send disconnect'
params: NonReducibleUnknown
}
'send handshake syn': {
type: 'send handshake syn'
params: NonReducibleUnknown
}
'send pending messages': {
type: 'send pending messages'
params: NonReducibleUnknown
}
'set target': {
type: 'set target'
params: NonReducibleUnknown
}
}>,
Values<{
'has target': {
type: 'has target'
params: unknown
}
'should send heartbeats': {
type: 'should send heartbeats'
params: unknown
}
}>,
never,
| 'idle'
| 'handshaking'
| 'disconnected'
| {
connected: {
heartbeat: 'sending' | 'checking'
}
},
string,
ConnectionInput,
NonReducibleUnknown,
| StatusEmitEvent
| BufferAddedEmitEvent<TSendsWithoutResponse>
| BufferFlushedEmitEvent<TSendsWithoutResponse>
| MessageEmitEvent<TReceives>,
MetaObject,
{
/** @xstate-layout N4IgpgJg5mDOIC5QGMAWBDAdpsAbAxAC7oBOMhAdLGIQNoAMAuoqAA4D2sAloV+5ixAAPRAHZRAJgoAWABz0ArHICMy2QGZZCgJwAaEAE9EE+tIrb6ANgkLl46fTuj1AXxf60WHARJgAjgCucJSwAcjIcLAMzEggHNy8-IIiCKLS2hQS6qb2yurisrL6RgjK9LIyCuqq0g7WstZuHhjYePi+gcEUAGboXLiQ0YLxPHwCsSmiCgoykpayDtqS6trqxYjKEk0gnq24FFwQA-jI-DjIdEzDnKNJExuOZpZ12eq29OrSCuupypYUojUaTKCnm5Wk2123gORzA+HilxibBuiXGoBSGnUAIU4gU9FWamUtR+lmUM1EllBEkslMUEnpkJa0JaEFgGAA1lxMFB8LADJghrERqjkhtshk3mTtNo5OpqpYfqCKhTptoqpY1WUtu4dky8BQWWz0Jzue1-EFYIjrgkxqLSupqRRPpoPqJtLI0hIioZENJJE7NnJ8ZYHVk1YyvPrDRyuTyEYLkTa7uixVlMh81KGFhS1j6EPkZlpVjTphr8mkI3sDVhWTHTQBbSLoGAUXwRLgAN0GVyFKNt91KimUFEKXvKC2s9R+6X+jipnzJeSqEJ1UKjNaNJp5EC4sFOrQuCbifeTwg2cgoym0RPxDtqkj0eaB9Ao8zSolMEivZVcq71+33c5CEgeFOCtXskzRM8EDxKRpmkSw3QJbQsmpH5tHmV8JHSbJpDsakV2aSMALOMALhAjoLXAxNbiglI-SxWw1Vw0QNDw0Qfg9KQ7EJSxHHxApK2hQCyOAiAzVgDhMGoI9hX7FMEHSF8cWkelpHURCbBsb481xAEgT9BQJCmWQsiE-URPI8TG1gWBmzAVsyLATtuyRY9ILtWoKmlL82Kqd0tAVJ91LMHFZDKIkVlkNVZHMkiDzE-Adz3UjDx7GiRQHCKnheD53k+HSSkDDIwpBVTqQwuKKEssSDTAUhCAAI3qyg0DIrd8Fkk86MQUMnVM+RynoegTDJH48hGp0vR-FDRqqKqasgOqGua9AQjATAd1NSiul6fpXOtWi7Wy19cslD4vnG7IX3oVjVDUVYEJQqrksW8SdstLqPKy0wKgG1RhtMWogqKhoMjkWp6XxUyFBe3c3tAz70vco6fq+V8PTkGUFzdQqNnELEM2yClrwwzQ4ZShKQJqr7UYU98AS0W9pT4z5pHG0yXwMkNNTyGk3B1TB2AgOBBDXXBDsyhSFG9EovQqN5i1JeRcKqw4Bkl+ToMx8x0j+EaqQ9XMSkBURMgMkEwQWKro2NWNNdPFJAzN0lJGM4slDxhBEJfXyplBd03wW1KxIdnrBxBh4JAyW75C8rJpmDqmIGWkgmpasPjqUcaHooMLHA0uU1UkJOgKW1B6rT1bWor5At0zgcTAkK7hrz1irB0D8cW0UvRPLyv07WqgNq2qAG+l9SnXUz0UOXD5xuMs3Y4+DVJBX7UiKrV6Q8gcfoJO54rFefLLqfJYX1WKYNLxL4NO1NwgA */
readonly id: 'connection'
readonly context: ({
input,
}: {
spawn: {
<TSrc extends 'listen' | 'sendBackAtInterval' | 'requestMachine'>(
logic: TSrc,
...[options]:
| ({
src: 'listen'
logic: ObservableActorLogic<
{
type: string
message: MessageEvent<ProtocolMessage>
},
ListenInput,
EventObject
>
id: 'listen for handshake' | 'listen for messages'
} extends infer T
? T extends {
src: 'listen'
logic: ObservableActorLogic<
{
type: string
message: MessageEvent<ProtocolMessage>
},
ListenInput,
EventObject
>
id: 'listen for handshake' | 'listen for messages'
}
? T extends {
src: TSrc
}
? ConditionalRequired<
[
options?:
| ({
id?: T['id'] | undefined
systemId?: string
input?: InputFrom<T['logic']> | undefined
syncSnapshot?: boolean
} & {[K in RequiredActorOptions<T>]: unknown})
| undefined,
],
IsNotNever<RequiredActorOptions<T>>
>
: never
: never
: never)
| ({
src: 'sendBackAtInterval'
logic: CallbackActorLogic<
EventObject,
{
event: EventObject
immediate?: boolean
interval: number
},
EventObject
>
id: 'send heartbeat' | 'send syn'
} extends infer T_1
? T_1 extends {
src: 'sendBackAtInterval'
logic: CallbackActorLogic<
EventObject,
{
event: EventObject
immediate?: boolean
interval: number
},
EventObject
>
id: 'send heartbeat' | 'send syn'
}
? T_1 extends {
src: TSrc
}
? ConditionalRequired<
[
options?:
| ({
id?: T_1['id'] | undefined
systemId?: string
input?: InputFrom<T_1['logic']> | undefined
syncSnapshot?: boolean
} & {[K_1 in RequiredActorOptions<T_1>]: unknown})
| undefined,
],
IsNotNever<RequiredActorOptions<T_1>>
>
: never
: never
: never)
| ({
src: 'requestMachine'
logic: StateMachine<
RequestMachineContext<TSends>,
| {
type: 'message'
data: ProtocolMessage<ResponseMessage>
}
| {
type: 'abort'
},
{
'listen for response'?:
| ActorRefFromLogic<
ObservableActorLogic<
MessageEvent<ProtocolMessage<ResponseMessage>>,
{
requestId: string
sources: Set<MessageEventSource>
signal?: AbortSignal
},
EventObject
>
>
| undefined
},
{
src: 'listen'
logic: ObservableActorLogic<
MessageEvent<ProtocolMessage<ResponseMessage>>,
{
requestId: string
sources: Set<MessageEventSource>
signal?: AbortSignal
},
EventObject
>
id: 'listen for response'
},
Values<{
'send message': {
type: 'send message'
params: {
message: ProtocolMessage
}
}
'on success': {
type: 'on success'
params: NonReducibleUnknown
}
'on fail': {
type: 'on fail'
params: NonReducibleUnknown
}
'on abort': {
type: 'on abort'
params: NonReducibleUnknown
}
}>,
{
type: 'expectsResponse'
params: unknown
},
'initialTimeout' | 'responseTimeout',
'idle' | 'sending' | 'awaiting' | 'success' | 'aborted' | 'failed',
string,
{
channelId: string
data?: TSends['data'] | undefined
domain: string
expectResponse?: boolean
from: string
parentRef: AnyActorRef
resolvable?: PromiseWithResolvers<TSends['response']> | undefined
responseTimeout?: number
responseTo?: string
signal?: AbortSignal
sources: Set<MessageEventSource> | MessageEventSource
suppressWarnings?: boolean
targetOrigin: string
to: string
type: TSends['type']
},
{
requestId: string
response: TSends['response'] | null
responseTo: string | undefined
},
| {
type: 'request.failed'
requestId: string
}
| {
type: 'request.aborted'
requestId: string
}
| {
type: 'request.success'
requestId: string
response: MessageData | null
responseTo: string | undefined
},
MetaObject,
{
readonly context: ({
input,
}: {
spawn: {
<TSrc_1 extends 'listen'>(
logic: TSrc_1,
...[options]: {
src: 'listen'
logic: ObservableActorLogic<
MessageEvent<ProtocolMessage<ResponseMessage>>,
{
requestId: string
sources: Set<MessageEventSource>
signal?: AbortSignal
},
EventObject
>
id: 'listen for response'
} extends infer T_2
? T_2 extends {
src: 'listen'
logic: ObservableActorLogic<
MessageEvent<ProtocolMessage<ResponseMessage>>,
{
requestId: string
sources: Set<MessageEventSource>
signal?: Abo