current-sample-invocations.ts

import { Effect, Event, sample, Store, Unit } from "effector"

declare let unit: Unit<number>
declare let store: Store<number>
declare let event: Event<number>
declare let effect: Effect<number, number>

store = sample(store)
store = sample(store, store)
event = sample(store, event)
event = sample(store, effect)
store = sample(store, store, (source, clock) => source + clock)
event = sample(store, event, (source, clock) => source + clock)
event = sample(store, effect, (source, clock) => source + clock)

event = sample(event, store)
event = sample(event, event)
event = sample(event, effect)
event = sample(event, store, (source, clock) => source + clock)
event = sample(event, event, (source, clock) => source + clock)
event = sample(event, effect, (source, clock) => source + clock)

event = sample(effect, store)
event = sample(effect, event)
event = sample(effect, effect)
event = sample(effect, store, (source, clock) => source + clock)
event = sample(effect, event, (source, clock) => source + clock)
event = sample(effect, effect, (source, clock) => source + clock)

store = sample({ source: store })
store = sample({ source: store, clock: store })
event = sample({ source: store, clock: event })
event = sample({ source: store, clock: effect })
store = sample({ source: store, clock: store, fn: (source, clock) => source + clock })
event = sample({ source: store, clock: event, fn: (source, clock) => source + clock })
event = sample({ source: store, clock: effect, fn: (source, clock) => source + clock })

event = sample({ source: event })
event = sample({ source: event, clock: store })
event = sample({ source: event, clock: event })
event = sample({ source: event, clock: effect })
event = sample({ source: event, clock: store, fn: (source, clock) => source + clock })
event = sample({ source: event, clock: event, fn: (source, clock) => source + clock })
event = sample({ source: event, clock: effect, fn: (source, clock) => source + clock })

event = sample({ source: effect })
event = sample({ source: effect, clock: store })
event = sample({ source: effect, clock: event })
event = sample({ source: effect, clock: effect })
event = sample({ source: effect, clock: store, fn: (source, clock) => source + clock })
event = sample({ source: effect, clock: event, fn: (source, clock) => source + clock })
event = sample({ source: effect, clock: effect, fn: (source, clock) => source + clock })

// TARGET FORWARDING

unit = sample({ source: store, clock: store, target: store })
unit = sample({ source: store, clock: event, target: store })
unit = sample({ source: store, clock: effect, target: store })
unit = sample({ source: store, clock: store, fn: (source, clock) => source + clock, target: store })
unit = sample({ source: store, clock: event, fn: (source, clock) => source + clock, target: store })
unit = sample({ source: store, clock: effect, fn: (source, clock) => source + clock, target: store })

unit = sample({ source: store, clock: store, target: event })
unit = sample({ source: store, clock: event, target: event })
unit = sample({ source: store, clock: effect, target: event })
unit = sample({ source: store, clock: store, fn: (source, clock) => source + clock, target: event })
unit = sample({ source: store, clock: event, fn: (source, clock) => source + clock, target: event })
unit = sample({ source: store, clock: effect, fn: (source, clock) => source + clock, target: event })

unit = sample({ source: store, clock: store, target: effect })
unit = sample({ source: store, clock: event, target: effect })
unit = sample({ source: store, clock: effect, target: effect })
unit = sample({ source: store, clock: store, fn: (source, clock) => source + clock, target: effect })
unit = sample({ source: store, clock: event, fn: (source, clock) => source + clock, target: effect })
unit = sample({ source: store, clock: effect, fn: (source, clock) => source + clock, target: effect })

unit = sample({ source: event, clock: store, target: store })
unit = sample({ source: event, clock: event, target: store })
unit = sample({ source: event, clock: effect, target: store })
unit = sample({ source: event, clock: store, fn: (source, clock) => source + clock, target: store })
unit = sample({ source: event, clock: event, fn: (source, clock) => source + clock, target: store })
unit = sample({ source: event, clock: effect, fn: (source, clock) => source + clock, target: store })

unit = sample({ source: event, clock: store, target: event })
unit = sample({ source: event, clock: event, target: event })
unit = sample({ source: event, clock: effect, target: event })
unit = sample({ source: event, clock: store, fn: (source, clock) => source + clock, target: event })
unit = sample({ source: event, clock: event, fn: (source, clock) => source + clock, target: event })
unit = sample({ source: event, clock: effect, fn: (source, clock) => source + clock, target: event })

unit = sample({ source: event, clock: store, target: effect })
unit = sample({ source: event, clock: event, target: effect })
unit = sample({ source: event, clock: effect, target: effect })
unit = sample({ source: event, clock: store, fn: (source, clock) => source + clock, target: effect })
unit = sample({ source: event, clock: event, fn: (source, clock) => source + clock, target: effect })
unit = sample({ source: event, clock: effect, fn: (source, clock) => source + clock, target: effect })

unit = sample({ source: effect, clock: store, target: store })
unit = sample({ source: effect, clock: event, target: store })
unit = sample({ source: effect, clock: effect, target: store })
unit = sample({ source: effect, clock: store, fn: (source, clock) => source + clock, target: store })
unit = sample({ source: effect, clock: event, fn: (source, clock) => source + clock, target: store })
unit = sample({ source: effect, clock: effect, fn: (source, clock) => source + clock, target: store })

unit = sample({ source: effect, clock: store, target: event })
unit = sample({ source: effect, clock: event, target: event })
unit = sample({ source: effect, clock: effect, target: event })
unit = sample({ source: effect, clock: store, fn: (source, clock) => source + clock, target: event })
unit = sample({ source: effect, clock: event, fn: (source, clock) => source + clock, target: event })
unit = sample({ source: effect, clock: effect, fn: (source, clock) => source + clock, target: event })

unit = sample({ source: effect, clock: store, target: effect })
unit = sample({ source: effect, clock: event, target: effect })
unit = sample({ source: effect, clock: effect, target: effect })
unit = sample({ source: effect, clock: store, fn: (source, clock) => source + clock, target: effect })
unit = sample({ source: effect, clock: event, fn: (source, clock) => source + clock, target: effect })
unit = sample({ source: effect, clock: effect, fn: (source, clock) => source + clock, target: effect })

new-overload.ts

// Type for extention purpose. Represents combinable sample source.
type Combinable = { [key: string]: Store<any> } | Tuple<Store<any>>
// Helper type, which unwraps combinable sample source value.
type GetCombinedValue<T> = {[K in keyof T]: T[K] extends Store<infer U> ? U : never}

// ...
//
// new overloads
                                                               
// I

export function sample<A extends Combinable>(
  source: A,
  clock: Event<any> | Effect<any, any, any>,
): Event<GetCombinedValue<A>>
export function sample<A extends Combinable, B, C>(
  source: A,
  clock: Store<B>,
  fn: (source: GetCombinedValue<A>, clock: B) => C,
  greedy?: boolean,
): Store<C>
export function sample<A extends Combinable, B, C>(
  source: A,
  clock: Store<B>,
  fn: (source: GetCombinedValue<A>, clock: B) => C,
  greedy?: boolean,
): Store<C>
export function sample<A extends Combinable, B, C>(
  source: A,
  clock: Event<B> | Effect<B, any, any>,
  fn: (source: GetCombinedValue<A>, clock: B) => C,
  greedy?: boolean,
): Event<C>

// II

export function sample<A extends Combinable>(config: {
  source: A
  clock: Store<any>
  name?: string
  greedy?: boolean
}): Store<GetCombinedValue<A>>
export function sample<A extends Combinable>(config: {
  source: A
  clock: Event<any> | Effect<any, any, any>
  name?: string
  greedy?: boolean
}): Event<GetCombinedValue<A>>
export function sample<A extends Combinable, B, C>(config: {
  source: A
  clock: Store<B>
  fn(source: GetCombinedValue<A>, clock: B): C
  name?: string
  greedy?: boolean
}): Store<C>
export function sample<A extends Combinable, B, C>(config: {
  source: A
  clock: Event<B> | Effect<B, any, any>
  fn(source: GetCombinedValue<A>, clock: B): C
  name?: string
  greedy?: boolean
}): Event<C>

// III

export function sample<A extends Combinable>(config: {
  source: A
  clock: Unit<any>
  target: Unit<GetCombinedValue<A>>
  greedy?: boolean
}): Unit<GetCombinedValue<A>>
export function sample<A extends Combinable, B, C>(config: {
  source: A
  clock: Unit<B>
  fn(source: GetCombinedValue<A>, clock: B): C
  target: Unit<C>
  greedy?: boolean
}): Unit<C>

new-sample-with-source-combine-api.ts

import { Effect, Event, sample, Store, Unit } from "effector"

declare let store: Store<number>
declare let event: Event<number>
declare let effect: Effect<number, any, any>

// I

event = sample({ store }, event).map(({ store }) => store)
event = sample({ store }, effect).map(({ store }) => store)
store = sample({ store }, store, ({ store }, clock) => store + clock)
event = sample({ store }, event, ({ store }, clock) => store + clock)
event = sample({ store }, effect, ({ store }, clock) => store + clock)
event = sample([store], event).map(([store]) => store)
event = sample([store], effect).map(([store]) => store)
store = sample([store], store, ([store], clock) => store + clock)
event = sample([store], event, ([store], clock) => store + clock)
event = sample([store], effect, ([store], clock) => store + clock)

// II

// store = sample({ source: { store } }) // useless case
store = sample({ source: { store }, clock: store }).map(({ store }) => store)
event = sample({ source: { store }, clock: event }).map(({ store }) => store)
event = sample({ source: { store }, clock: effect }).map(({ store }) => store)
store = sample({ source: { store }, clock: store, fn: ({ store }, clock) => store + clock })
event = sample({ source: { store }, clock: event, fn: ({ store }, clock) => store + clock })
event = sample({ source: { store }, clock: effect, fn: ({ store }, clock) => store + clock })

store = sample({ source: [store], clock: store }).map(([store]) => store)
event = sample({ source: [store], clock: event }).map(([store]) => store)
event = sample({ source: [store], clock: effect }).map(([store]) => store)
store = sample({ source: [store], clock: store, fn: ([store], clock) => store + clock })
event = sample({ source: [store], clock: event, fn: ([store], clock) => store + clock })
event = sample({ source: [store], clock: effect, fn: ([store], clock) => store + clock })

// III

declare let unit_num: Unit<number>
declare let unit_obj: Unit<{ store: number }>
declare let unit_arr: Unit<[number]>

unit_obj = sample({ source: { store }, clock: store, target: unit_obj })
unit_obj = sample({ source: { store }, clock: event, target: unit_obj })
unit_obj = sample({ source: { store }, clock: effect, target: unit_obj })
unit_num = sample({ source: { store }, clock: store, fn: ({ store }, clock) => store + clock, target: unit_num })
unit_num = sample({ source: { store }, clock: event, fn: ({ store }, clock) => store + clock, target: unit_num })
unit_num = sample({ source: { store }, clock: effect, fn: ({ store }, clock) => store + clock, target: unit_num })

unit_arr = sample({ source: [store], clock: store, target: unit_arr })
unit_arr = sample({ source: [store], clock: event, target: unit_arr })
unit_arr = sample({ source: [store], clock: effect, target: unit_arr })
unit_num = sample({ source: [store], clock: store, fn: ([store], clock) => store + clock, target: unit_num })
unit_num = sample({ source: [store], clock: event, fn: ([store], clock) => store + clock, target: unit_num })
unit_num = sample({ source: [store], clock: effect, fn: ([store], clock) => store + clock, target: unit_num })