This type represents T as not only potentially nullable data, but also as a data which can not be presented. This type will be useful in cases when T is nullable and null as valuable data too in time of data absence should be presented by some third type.

PreviewFeature

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FIELD, AnnotationTarget.PROPERTY, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.FUNCTION, AnnotationTarget.TYPEALIAS])

annotation class PreviewFeature(val message: String = "It is possible, that behaviour of this thing will be changed or removed in future releases")

Progress

@Serializable

@JvmInline

value class Progress

ResizeObserver

external class ResizeObserver(callback: (Array<ResizeObserverEntry>, ResizeObserver) -> Unit)

ResizeObserverEntry

external interface ResizeObserverEntry

ResizeObserverObserveOptions

class ResizeObserverObserveOptions(val box: ResizeObserverObserveOptions.Box? = null)

ResizeObserverSize

external interface ResizeObserverSize

SimpleMapper

interface SimpleMapper<T1, T2>

SimpleMapperImpl

class SimpleMapperImpl<T1, T2>(t1: (T2) -> T1, t2: (T1) -> T2) : SimpleMapper<T1, T2>

SimpleSuspendableMapper

interface SimpleSuspendableMapper<T1, T2>

SimpleSuspendableMapperImpl

class SimpleSuspendableMapperImpl<T1, T2>(t1: suspend (T2) -> T1, t2: suspend (T1) -> T2) : SimpleSuspendableMapper<T1, T2>

SuspendByteArrayAllocator

typealias SuspendByteArrayAllocator = suspend () -> ByteArray

Visibility

sealed class Visibility

Visible

object Visible : Visibility

Warning

annotation class Warning(val message: String)

Properties

asAllocator

val ByteArray.asAllocator: ByteArrayAllocator

asSuspendAllocator

val ByteArray.asSuspendAllocator: SuspendByteArrayAllocator

val ByteArrayAllocator.asSuspendAllocator: SuspendByteArrayAllocator

bytesAllocator

expect val MPPFile.bytesAllocator: SuspendByteArrayAllocator

bytesAllocatorSync

expect val MPPFile.bytesAllocatorSync: ByteArrayAllocator

disabled

val View.disabled: Boolean

enabled

val View.enabled: Boolean

filename

expect val MPPFile.filename: FileName

filesize

expect val MPPFile.filesize: Long

FixedSignsRange

val FixedSignsRange: IntRange

gone

val View.gone: Boolean

hidden

val View.hidden: Boolean

isCollapsed

val View.isCollapsed: Boolean

isExpanded

val View.isExpanded: Boolean

isGone

val Element.isGone: Boolean

isInvisible

val Element.isInvisible: Boolean

isOnScreen

val DOMRect.isOnScreen: Boolean

val Element.isOnScreen: Boolean

isOnScreenByBottomEdge

val DOMRect.isOnScreenByBottomEdge: Boolean

val Element.isOnScreenByBottomEdge: Boolean

isOnScreenByLeftEdge

val DOMRect.isOnScreenByLeftEdge: Boolean

val Element.isOnScreenByLeftEdge: Boolean

isOnScreenByRightEdge

val DOMRect.isOnScreenByRightEdge: Boolean

val Element.isOnScreenByRightEdge: Boolean

isOnScreenByTopEdge

val DOMRect.isOnScreenByTopEdge: Boolean

val Element.isOnScreenByTopEdge: Boolean

isOnScreenFully

val DOMRect.isOnScreenFully: Boolean

val Element.isOnScreenFully: Boolean

isOverflow

val Element.isOverflow: Boolean

isOverflowHeight

val Element.isOverflowHeight: Boolean

isOverflowWidth

val Element.isOverflowWidth: Boolean

isVisible

val Element.isVisible: Boolean

optional

val <T> T.optional: Optional<T>

optionalOrAbsentIfNull

val <T : Any> T?.optionalOrAbsentIfNull: Optional<T>

rootView

val Activity.rootView: View?

shown

val View.shown: Boolean

visibilityState

var Element.visibilityState: Visibility

var CSSStyleDeclaration.visibilityState: Visibility

Functions

alsoIfFalse

inline fun Boolean.alsoIfFalse(block: () -> Unit): Boolean

alsoIfTrue

inline fun Boolean.alsoIfTrue(block: () -> Unit): Boolean

applyDiff

fun <T> MutableList<T>.applyDiff(diff: Diff<T>)

Applies diff to this

fun <K, V> MutableMap<K, V>.applyDiff(mapDiff: MapDiff<K, V>)

Will apply mapDiff to this

fun <T> MutableList<T>.applyDiff(source: Iterable<T>, strictComparison: Boolean = false): Diff<T>

This method call calculateDiff with strict mode strictComparison and then apply differences to this mutable list

fun <T> MutableList<T>.applyDiff(source: Iterable<T>, comparisonFun: (T?, T?) -> Boolean): Diff<T>

This method call calculateDiff and then apply differences to this mutable list

fun <K, V> MutableMap<K, V>.applyDiff(from: Map<K, V>, strictComparison: Boolean = false): MapDiff<K, V>

fun <K, V> MutableMap<K, V>.applyDiff(from: Map<K, V>, compareFun: (K, V, V) -> Boolean): MapDiff<K, V>

Will apply changes with from map into this one

argumentOrNull

fun argumentOrNull(): ArgumentPropertyNullableDelegate

argumentOrThrow

fun argumentOrThrow(): ArgumentPropertyNonNullableDelegate

asAllocator

suspend fun SuspendByteArrayAllocator.asAllocator(): ByteArrayAllocator

await

suspend fun <T> Promise<T>.await(): T

bytes

suspend fun MPPFile.bytes(): ByteArray

bytesSync

fun MPPFile.bytesSync(): ByteArray

calculateDiff

fun <T> Iterable<T>.calculateDiff(other: Iterable<T>, strictComparison: Boolean = false): Diff<T>

fun <T> Iterable<T>.calculateDiff(other: Iterable<T>, comparisonFun: (T?, T?) -> Boolean): Diff<T>

Calculating Diff object

calculateStrictDiff

inline fun <T> Iterable<T>.calculateStrictDiff(other: Iterable<T>): Diff<T>

This method call calculateDiff with strict mode enabled

changeVisibility

fun View.changeVisibility(show: Boolean = !isShown, goneOnHide: Boolean = true)

collapse

fun View.collapse(duration: Long = 500)

collapseHorizontally

fun View.collapseHorizontally(duration: Long = 500)

compareTo

operator fun Progress.compareTo(other: Progress): Int

convert

@JvmName(name = "convertFromT2")

fun <T1, T2> SimpleMapper<T1, T2>.convert(from: T2): T1

@JvmName(name = "convertFromT1")

fun <T1, T2> SimpleMapper<T1, T2>.convert(from: T1): T2

@JvmName(name = "convertFromT2")

suspend fun <T1, T2> SimpleSuspendableMapper<T1, T2>.convert(from: T2): T1

@JvmName(name = "convertFromT1")

suspend fun <T1, T2> SimpleSuspendableMapper<T1, T2>.convert(from: T1): T2

dataOrElse

inline fun <T> Optional<T>.dataOrElse(block: () -> T): T

Returns Optional.data if Optional.dataPresented of this is true, or call block and returns the result of it

dataOrNull

fun <T> Optional<T>.dataOrNull(): T?

Returns Optional.data if Optional.dataPresented of this is true, or null otherwise

dataOrThrow

fun <T> Optional<T>.dataOrThrow(throwable: Throwable): T

Returns Optional.data if Optional.dataPresented of this is true, or throw throwable otherwise

Diff

inline fun <T> Diff(old: Iterable<T>, new: Iterable<T>): Diff<T>

diff

inline fun <T> Iterable<T>.diff(other: Iterable<T>, strictComparison: Boolean = false): Diff<T>

inline fun <T> Iterable<T>.diff(other: Iterable<T>, noinline comparisonFun: (T?, T?) -> Boolean): Diff<T>

fun <K, V> Map<K, V>.diff(other: Map<K, V>, strictComparison: Boolean = false): MapDiff<K, V>

fun <K, V> Map<K, V>.diff(other: Map<K, V>, compareFun: (K, V, V) -> Boolean): MapDiff<K, V>

Compare this with the other one in principle when other is newer than this

disable

fun View.disable()

div

operator fun Progress.div(i: Byte): Progress

operator fun Progress.div(i: Double): Progress

operator fun Progress.div(i: Float): Progress

operator fun Progress.div(i: Int): Progress

operator fun Progress.div(i: Long): Progress

operator fun Progress.div(i: Short): Progress

downloadToTempFile

fun InputStream.downloadToTempFile(fileName: String = UUID.randomUUID().toString(), fileExtension: String? = ".temp", folder: File? = null): File

either

inline fun <T1, T2> Any.either(): <Error class: unknown class>

emptyDiff

fun <T> emptyDiff(): Diff<T>

enable

fun View.enable()

expand

fun View.expand(duration: Long = 500, targetWidth: Int = ViewGroup.LayoutParams.MATCH_PARENT, targetHeight: Int = ViewGroup.LayoutParams.WRAP_CONTENT)

expandHorizontally

fun View.expandHorizontally(duration: Long = 500, targetWidth: Int = ViewGroup.LayoutParams.MATCH_PARENT, targetHeight: Int = ViewGroup.LayoutParams.WRAP_CONTENT)

findViewsByTag