combine | /packages/effector/index.d.ts | effector@effector@23.2.2

function combine

import { combine } from "https://deno.land/x/effector@effector%4023.2.2/packages/effector/index.d.ts";

combine<T extends Store<any>>(store: T): T extends Store<infer R> ? Store<[R]> : never

Convert given stores to store with array which values updated upon changes in given ones

combine<State extends Tuple>(tuple: State): Store<[K in keyof State]: State[K] extends Store<infer U> ? U : State[K]>

Convert array of stores to store with array which values updated upon changes in given ones

combine<State>(shape: CombineState<State>): Store<State>

Convert object with stores to object store which fields updated upon changes in given ones

combine<State>(shape: State): Store<[K in keyof State]: State[K] extends Store<infer U> ? U : State[K]>

Convert object with stores to object store which fields updated upon changes in given ones

combine<A, R>(

source: Store<A>,

fn: (source: A) => R,

config?: { skipVoid: boolean; },

): Store<R>

Creates derived store from given one, transforming value using the function

combine<State extends Tuple, R>(

tuple: State,

fn: (tuple: [K in keyof State]: State[K] extends Store<infer U> ? U : State[K]) => R,

config?: { skipVoid: boolean; },

): Store<R>

Convert array of stores into derived store, transforming values using the function

combine<State, R>(

shape: State,

fn: (shape: [K in keyof State]: State[K] extends Store<infer U> ? U : State[K]) => R,

config?: { skipVoid: boolean; },

): Store<R>

Convert object with stores into derived store, transforming values using the function

combine<A, B, R>(

a: A,

b: B,

fn: (a: CombVal<A>, b: CombVal) => R,

config?: { skipVoid: boolean; },

): Store<R>

Convert given stores into derived store, transforming values using the function

combine<A, B, C, R>(

a: A,

b: B,

c: C,

fn: (

a: CombVal<A>,

b: CombVal,

c: CombVal<C>,

) => R,

config?: { skipVoid: boolean; },

): Store<R>

Convert given stores into derived store, transforming values using the function

combine<A, B, C, D, R>(

a: A,

b: B,

c: C,

d: D,

fn: (

a: CombVal<A>,

b: CombVal,

c: CombVal<C>,

d: CombVal<D>,

) => R,

config?: { skipVoid: boolean; },

): Store<R>

Convert given stores into derived store, transforming values using the function

combine<A, B, C, D, E, R>(

a: A,

b: B,

c: C,

d: D,

e: E,

fn: (

a: CombVal<A>,

b: CombVal,

c: CombVal<C>,

d: CombVal<D>,

e: CombVal<E>,

) => R,

config?: { skipVoid: boolean; },

): Store<R>

Convert given stores into derived store, transforming values using the function

combine<A, B, C, D, E, F, R>(

a: A,

b: B,

c: C,

d: D,

e: E,

f: F,

fn: (

a: CombVal<A>,

b: CombVal,

c: CombVal<C>,

d: CombVal<D>,

e: CombVal<E>,

f: CombVal<F>,

) => R,

config?: { skipVoid: boolean; },

): Store<R>

Convert given stores into derived store, transforming values using the function

combine<A, B, C, D, E, F, G, R>(

a: A,

b: B,

c: C,

d: D,

e: E,

f: F,

g: G,

fn: (

a: CombVal<A>,

b: CombVal,

c: CombVal<C>,

d: CombVal<D>,

e: CombVal<E>,

f: CombVal<F>,

g: CombVal<G>,

) => R,

config?: { skipVoid: boolean; },

): Store<R>

Convert given stores into derived store, transforming values using the function

combine<A, B, C, D, E, F, G, H, R>(

a: A,

b: B,

c: C,

d: D,

e: E,

f: F,

g: G,

h: H,

fn: (

a: CombVal<A>,

b: CombVal,

c: CombVal<C>,

d: CombVal<D>,

e: CombVal<E>,

f: CombVal<F>,

g: CombVal<G>,

h: CombVal<H>,

) => R,

config?: { skipVoid: boolean; },

): Store<R>

Convert given stores into derived store, transforming values using the function

combine<A, B, C, D, E, F, G, H, I, R>(

a: A,

b: B,

c: C,

d: D,

e: E,

f: F,

g: G,

h: H,

i: I,

fn: (

a: CombVal<A>,

b: CombVal,

c: CombVal<C>,

d: CombVal<D>,

e: CombVal<E>,

f: CombVal<F>,

g: CombVal<G>,

h: CombVal<H>,

i: CombVal,

) => R,

config?: { skipVoid: boolean; },

): Store<R>

Convert given stores into derived store, transforming values using the function

combine<A, B, C, D, E, F, G, H, I, J, R>(

a: A,

b: B,

c: C,

d: D,

e: E,

f: F,

g: G,

h: H,

i: I,

j: J,

fn: (

a: CombVal<A>,

b: CombVal,

c: CombVal<C>,

d: CombVal<D>,

e: CombVal<E>,

f: CombVal<F>,

g: CombVal<G>,

h: CombVal<H>,

i: CombVal,

j: CombVal<J>,

) => R,

config?: { skipVoid: boolean; },

): Store<R>

Convert given stores into derived store, transforming values using the function

combine<A, B, C, D, E, F, G, H, I, J, K, R>(

a: A,

b: B,

c: C,

d: D,

e: E,

f: F,

g: G,

h: H,

i: I,

j: J,

k: K,

fn: (

a: CombVal<A>,

b: CombVal,

c: CombVal<C>,

d: CombVal<D>,

e: CombVal<E>,

f: CombVal<F>,

g: CombVal<G>,

h: CombVal<H>,

i: CombVal,

j: CombVal<J>,

k: CombVal<K>,

) => R,

config?: { skipVoid: boolean; },

): Store<R>

Convert given stores into derived store, transforming values using the function

combine<T extends Tuple<Store<any> | any>>(...stores: T): Store<[K in keyof T]: T[K] extends Store<infer U> ? U : T[K]>

Convert given stores to store with array which values updated upon changes in given ones

Type Parameters

T extends Store<any>

Parameters

store: T

Returns

T extends Store<infer R> ? Store<[R]> : never

derived store

Convert array of stores to store with array which values updated upon changes in given ones

Type Parameters

State extends Tuple

Parameters

tuple: State

array of stores

Returns

Store<[K in keyof State]: State[K] extends Store<infer U> ? U : State[K]>

derived store updated upon changes in given ones

Convert object with stores to object store which fields updated upon changes in given ones

Type Parameters

State

Parameters

shape: CombineState<State>

object with stores

Returns

Store<State>

derived store updated upon changes in given ones

Convert object with stores to object store which fields updated upon changes in given ones

Type Parameters

State

Parameters

shape: State

object with stores

Returns

Store<[K in keyof State]: State[K] extends Store<infer U> ? U : State[K]>

derived store updated upon changes in given ones

Creates derived store from given one, transforming value using the function

Type Parameters

Parameters

source: Store<A>

source store

fn: (source: A) => R

transformer function, accepts a store value

optional

config: { skipVoid: boolean; }

Returns

Store<R>

derived store updated upon changes in given one

Convert array of stores into derived store, transforming values using the function

Type Parameters

State extends Tuple

Parameters

tuple: State

array of stores

fn: (tuple: [K in keyof State]: State[K] extends Store<infer U> ? U : State[K]) => R

transformer function, accepts an array of values

optional

config: { skipVoid: boolean; }

Returns

Store<R>

derived store updated upon changes in given ones

Convert object with stores into derived store, transforming values using the function

Type Parameters

State

Parameters

shape: State

object with stores

fn: (shape: [K in keyof State]: State[K] extends Store<infer U> ? U : State[K]) => R

transformer function, accepts object with values

optional

config: { skipVoid: boolean; }

Returns

Store<R>

derived store updated upon changes in given ones

Convert given stores into derived store, transforming values using the function

Type Parameters

Parameters

a: A

transformer function, accepts store values in separate arguments

b: B

fn: (a: CombVal<A>, b: CombVal) => R

optional

config: { skipVoid: boolean; }

Returns

Store<R>

derived store updated upon changes in given ones

Convert given stores into derived store, transforming values using the function

Type Parameters

Parameters

a: A

transformer function, accepts store values in separate arguments

b: B

c: C

fn: (

a: CombVal<A>,

b: CombVal,

c: CombVal<C>,

) => R

optional

config: { skipVoid: boolean; }

Returns

Store<R>

derived store updated upon changes in given ones

Convert given stores into derived store, transforming values using the function

Type Parameters

Parameters

a: A

transformer function, accepts store values in separate arguments

b: B

c: C

d: D

fn: (

a: CombVal<A>,

b: CombVal,

c: CombVal<C>,

d: CombVal<D>,

) => R

optional

config: { skipVoid: boolean; }

Returns

Store<R>

derived store updated upon changes in given ones

Convert given stores into derived store, transforming values using the function

Type Parameters

Parameters

a: A

transformer function, accepts store values in separate arguments

b: B

c: C

d: D

e: E

fn: (

a: CombVal<A>,

b: CombVal,

c: CombVal<C>,

d: CombVal<D>,

e: CombVal<E>,

) => R

optional

config: { skipVoid: boolean; }

Returns

Store<R>

derived store updated upon changes in given ones

Convert given stores into derived store, transforming values using the function

Type Parameters

Parameters

a: A

transformer function, accepts store values in separate arguments

b: B

c: C

d: D

e: E

f: F

fn: (

a: CombVal<A>,

b: CombVal,

c: CombVal<C>,

d: CombVal<D>,

e: CombVal<E>,

f: CombVal<F>,

) => R

optional

config: { skipVoid: boolean; }

Returns

Store<R>

derived store updated upon changes in given ones

Convert given stores into derived store, transforming values using the function

Type Parameters

Parameters

a: A

transformer function, accepts store values in separate arguments

b: B

c: C

d: D

e: E

f: F

g: G

fn: (

a: CombVal<A>,

b: CombVal,

c: CombVal<C>,

d: CombVal<D>,

e: CombVal<E>,

f: CombVal<F>,

g: CombVal<G>,

) => R

optional

config: { skipVoid: boolean; }

Returns

Store<R>

derived store updated upon changes in given ones

Convert given stores into derived store, transforming values using the function

Consider using combine(arrayOfStores, arrayOfValues => ...) instead

Type Parameters

Parameters

a: A

transformer function, accepts store values in separate arguments

b: B

c: C

d: D

e: E

f: F

g: G

h: H

fn: (

a: CombVal<A>,

b: CombVal,

c: CombVal<C>,

d: CombVal<D>,

e: CombVal<E>,

f: CombVal<F>,

g: CombVal<G>,

h: CombVal<H>,

) => R

optional

config: { skipVoid: boolean; }

Returns

Store<R>

derived store updated upon changes in given ones

Convert given stores into derived store, transforming values using the function

Consider using combine(arrayOfStores, arrayOfValues => ...) instead

Type Parameters

Parameters

a: A

transformer function, accepts store values in separate arguments

b: B

c: C

d: D

e: E

f: F

g: G

h: H

i: I

fn: (

a: CombVal<A>,

b: CombVal,

c: CombVal<C>,

d: CombVal<D>,

e: CombVal<E>,

f: CombVal<F>,

g: CombVal<G>,

h: CombVal<H>,

i: CombVal,

) => R

optional

config: { skipVoid: boolean; }

Returns

Store<R>

derived store updated upon changes in given ones

Convert given stores into derived store, transforming values using the function

Consider using combine(arrayOfStores, arrayOfValues => ...) instead

Type Parameters

Parameters

a: A

transformer function, accepts store values in separate arguments

b: B

c: C

d: D

e: E

f: F

g: G

h: H

i: I

j: J

fn: (

a: CombVal<A>,

b: CombVal,

c: CombVal<C>,

d: CombVal<D>,

e: CombVal<E>,

f: CombVal<F>,

g: CombVal<G>,

h: CombVal<H>,

i: CombVal,

j: CombVal<J>,

) => R

optional

config: { skipVoid: boolean; }

Returns

Store<R>

derived store updated upon changes in given ones

Convert given stores into derived store, transforming values using the function

Consider using combine(arrayOfStores, arrayOfValues => ...) instead

Type Parameters

Parameters

a: A

transformer function, accepts store values in separate arguments

b: B

c: C

d: D

e: E

f: F

g: G

h: H

i: I

j: J

k: K

fn: (

a: CombVal<A>,

b: CombVal,

c: CombVal<C>,

d: CombVal<D>,

e: CombVal<E>,

f: CombVal<F>,

g: CombVal<G>,

h: CombVal<H>,

i: CombVal,

j: CombVal<J>,

k: CombVal<K>,

) => R

optional

config: { skipVoid: boolean; }

Returns

Store<R>

derived store updated upon changes in given ones

Convert given stores to store with array which values updated upon changes in given ones

Type Parameters

T extends Tuple<Store<any> | any>

Parameters

...stores: T

Returns

Store<[K in keyof T]: T[K] extends Store<infer U> ? U : T[K]>

derived store