SubStore

class SubStore<R, P, T>(parent: Store<P>, lens: Lens<P, T>, root: Store<R>, rootLens: Lens<R, T>) : Store<T>

A Store that is derived from your RootStore or another SubStore that represents a part of the data-model of it's parent. Use the .sub-factory-method on the parent Store to create it.

Constructors

SubStore

fun <R, P, T> SubStore(parent: Store<P>, lens: Lens<P, T>, root: Store<R>, rootLens: Lens<R, T>)

Functions

enqueue

open suspend override fun enqueue(update: QueuedUpdate<T>)

Since a SubStore is just a view on a RootStore holding the real value, it forwards the Update to it, using it's Lens to transform it.

equals

open operator fun equals(other: Any?): Boolean

errorHandler

open fun errorHandler(exception: Throwable, oldValue: T): T

Default error handler printing the error to console and keeping the previous value.

handle

open fun handle(errorHandler: ErrorHandler<T> = ::errorHandler, execute: suspend (T) -> T): SimpleHandler<Unit>

Factory method to create a SimpleHandler that does not take an Action

open fun <A> handle(errorHandler: ErrorHandler<T> = ::errorHandler, execute: suspend (T, A) -> T): SimpleHandler<A>

Factory method to create a SimpleHandler mapping the actual value of the Store and a given Action to a new value.

handleAndEmit

open fun <E> handleAndEmit(errorHandler: ErrorHandler<T> = ::errorHandler, execute: suspend FlowCollector<E>.(T) -> T): EmittingHandler<Unit, E>

factory method to create an EmittingHandler that does not take an action in it's execute-lambda.

open fun <A, E> handleAndEmit(errorHandler: ErrorHandler<T> = ::errorHandler, execute: suspend FlowCollector<E>.(T, A) -> T): EmittingHandler<A, E>

Factory method to create a EmittingHandler taking an action-value and the current store value to derive the new value.

handledBy

open infix fun <E : Event, X : Element> DomListener<E, X>.handledBy(handler: Handler<Unit>)

Connects Events to a Handler.

open infix fun <E : Event> WindowListener<E>.handledBy(handler: Handler<Unit>)

Connects Events to a Handler.

open infix fun <A> Flow<A>.handledBy(handler: Handler<A>)

Connects a Flow to a Handler.

hashCode

open fun hashCode(): Int

sub

fun <X> sub(lens: Lens<T, X>): SubStore<R, T, X>

creates a new SubStore using this one as it's parent.

syncBy

open fun syncBy(handler: Handler<T>)

calls a handler on each new value of the Store

open fun syncBy(handler: Handler<Unit>)

calls a handler on each new value of the Store

syncWith

open fun <I> syncWith(socket: Socket, resource: Resource<T, I>)

toString

open fun toString(): String

Properties

current

open override val current: T

represents the current value of the Store

data

open override val data: Flow<T>

the current value of the SubStore is derived from the data of it's parent using the given Lens.

open override val id: String

defines how to infer the id of the sub-part from the parent's id.

job

open override val job: Job

Job used as parent job on all coroutines started in Handlers in the scope of this Store

root

val root: Store<R>

update

open override val update: SimpleHandler<T>

a simple SimpleHandler that just takes the given action-value as the new value for the Store.

Extensions

sub

fun <R, P, T, I> SubStore<R, P, List<T>>.sub(element: T, idProvider: IdProvider<T, I>): SubStore<R, List<T>, T>

creates a SubStore using another SubStore as parent using a given IdProvider.

fun <R, P, T> SubStore<R, P, List<T>>.sub(index: Int): SubStore<R, List<T>, T>

creates a SubStore using a SubStore as parent using the index in the list (do not use this, if you want to manipulate the list itself (add or move elements, filter, etc.).