com.raquo.laminar.modifiers

Binder is a Modifier that creates a subscription when invoked.

• Note, this Modifier is NOT idempotent: Calling it N times will create and bind N subscriptions
• onMountBind can take care of this, see the docs

Note: this is a low level inserter. It is the fastest one, but due to its rather imperative API, its usefulness is very limited. It's good for simple but voluminous stuff, like appending new log items to a big list, but not much else.

Consider using children <-- observable.split(...) instead, it has great performance and is much more convenient.

This is like KeySetter, but for composite attributes like cls and role.

CompositeKeySetter can not be a subtype of KeySetter because we can not implement val value – the actual value to be set is dynamic, depending on the current value of the element's composite attribute.

Also, if you call cls := "class2" after calling cls := "class1", you end up with two classes instead of just "class2", which is different fro KeySetter semantics.

Note: for dynamic subscriptions (<--), we use KeyUpdater for all keys including composite attributes.

Inserter is a modifier that lets you insert child node(s) on mount. When used with onMountInsert, it "immediately" reserves an insertion spot and then on every mount it inserts the node(s) into the same spot.

Note: As a Modifier this is not idempotent, but overall it behaves as you would expect. See docs for more details.

Note: If you DO provide initialContext, its parentNode MUST always be the same element that you apply this Modifier to.

This class represents a modifier that sets a Key (e.g. an attribute or a style) to a specific value on a El. action is what performs this change.

These modifiers are not only idempotent, but are also expected to be undoable, that is, calling key := value2 will override key := value1. In contrast, that is not the case for cls := "class" for example, which adds a class instead of setting it. Such cls modifiers are CompositeKeySetter, which does not extend KeySetter. // #TODO the naming of these traits is confusing...

A modifier that updates a key from a source, e.g. value <-- valueStream

This type represents an operation that has a side effect on a node of type El.

For example: href := "http://example.com" is a Modifier that sets the href attribute to an example URL when invoked on an element (typically when the element is created, or if the modifier is added after the fact using the amend method, or by manually calling its apply method).

If you choose to extend this trait, make sure to understand how to use Transaction.onStart.shared. In simple cases, wrapping your callback in it similarly to Modifier.apply below will probably work. See https://github.com/raquo/Airstream/#restarting-streams-that-depend-on-signals--signalchanges-

RenderableNode[Component] is evidence that you can convert a Component to a Laminar ChildNode.

If you have an implicit val of RenderableNode[Component], Laminar can render your Component-s by converting them to ChildNode-s, and will accept your Component-s in child <--, children <--, etc.

A Component must have a 1-to-1 relationship to a Laminar ChildNode. Your Component class/trait should have something like val node: ChildNode.Base or lazy val node: ChildNode.Base in it, it must not be a var or a def.

See also – RenderableText

RenderableText[A] is evidence that you can convert a value of type A to a string for the purpose of rendering it as a TextNode.

If you have an implicit val of RenderableText[A], Laminar can render your A type values by converting them to strings (and ultimately into com.raquo.laminar.nodes.TextNode), and will accept your values as a valid Modifier, and in child.text <--.

See also – RenderableNode

This type represents a modifier that sets a "property" of an element.

It could be an html attribute, an event prop, or even a custom focus prop, the main constraint is that it should be idempotent, so that applying it several times in a row would produce the same effect as applying it once.

That way we can provide it to onMountSet { c => setter } and expect things to work if the element is mounted several times. However, note that CompositeKeySetter has special behaviour.