tornado.core — org.clojars.jansuran03/tornado 0.2.10

The core tornado namespace, where every single function or value you could need is defined and documented in this namespace.

active clj/s

CSS pseudoselector "active". Used as a value, e.g.: [:.some-sel {:width (px 100)} [active {:width (px 120)}]]

adjacent-sibling clj/s

(adjacent-sibling & selectors)

Coming soon

after clj/s

Coming soon

alter-meta-arglists! clj macro

(alter-meta-arglists! & fs)

at-font-face clj/s

(at-font-face & props-maps)

Can be used for more convenient describing of @font-face. This is how example props-maps look like:

{:src [[(url "../webfonts/woff2/roboto.woff2") (css-format :woff2)] [(url "../webfonts/woff/roboto.woff") (css-format :woff)]] :font-family "Roboto" :font-weight :normal :font-style :italic}

This function can receive any number of props maps so that you can also write the example above this way:

{:src (join (url "../webfonts/woff2/roboto.woff2") (css-format :woff2))} {:src (join (url "../webfonts/woff/roboto.woff") (css-format :woff)) :font-family "Roboto" :font-weight :normal :font-style :italic}

at-media clj/s

(at-media rules & changes)

Takes a rules map and any number of media changes and creates a CSSAtRule instance with "media" identifier:

(at-media {:screen :only :max-width (px 600) :min-width (px 800)} [:& {:margin (join 15 0 15 20)}] [:.abc #:def {:margin (px 20) :padding (join 30 15)} [:span {:background-color (mix-colors :red :green)}]] [:footer {:font-size (em 1)}])

The :& selector selects the current element. As you can see, you can nest the affected CSS hiccup how you only want. Special rules values: :screen :only => only screen :screen true => screen :screen false => not screen

{:screen true :speech false :max-width (px 600) :min-width (px 800)} => @media screen and not speech and (min-width: 600px) and (max-width: 800px) {...}

attr clj/s

(attr & args)

Coming soon

before clj/s

Coming soon

blur clj/s≠

clj

(blur arg)

cljs

(blur arg)

(blur arg & more)

Coming soon

brightness clj/s≠

clj

(brightness arg)

cljs

(brightness arg)

(brightness arg & more)

Coming soon

calc clj/s

(calc & args)

Coming soon

checked clj/s

CSS pseudoselector "checked". Used as a value, e.g.: [:.some-sel {:border [[(px 1) :solid :red]]} [checked {:border [[(px 1) :solid :crimson]]}]]

child-selector clj/s

(child-selector & selectors)

Coming soon

circle clj/s

(circle & args)

Coming soon

cm clj/s

(cm value)

An absolute length unit, "centimeter".

comma-join clj/s

(comma-join & args)

Coming soon

compile-expression clj/s

(compile-expression expr)

Compiles an expression: a number, string, symbol or a record. If the expression is a vector of sequential structures, compiles each of the structures and str/joins them with a space. Then, str/joins all these str/space-joined structures with a comma.

E.g.: (compile-expression [[(px 15) (percent 20)] [:red :chocolate]]) => "15px 20%, #FF0000 #D2691E"

compile-params clj/s

(compile-params attributes-map)

Given a map of HTML style attributes described in Tornado, compiles all the values of the parameters, but the parameters names remain the same. This function is useful for Reagent to allow you describing the style with Tornado. Example usage:

{:style (compile-params {:width (px 500) :background-color (important (rgb 100 150 200)) :border [[(px 1) :solid :black]] :display :flex})}

=> {:style {:width "500px", :background-color "rgb(100, 150, 200) !important", :border "1px solid #000000", :display "flex"}}

contains-subs clj/s

(contains-subs attribute subvalue)

(contains-subs tag attribute subvalue)

Selects all descendant elements which have a given parameter with a value containing a given substring (unlike the contains-word selector, the substring does not have to be a whole word).

contains-word clj/s

(contains-word attribute subvalue)

(contains-word tag attribute subvalue)

Selects all descendant elements which have a given parameter with a value containing a given word (substring is not enough - a matching word separated by commas or spaces).

contrast clj/s≠

clj

(contrast arg)

cljs

(contrast arg)

(contrast arg & more)

Coming soon

counter clj/s

(counter & args)

Coming soon

counters clj/s

(counters & args)

Coming soon

css clj/s

(css css-hiccup)

(css flags css-hiccup)

Generates CSS from a standard Tornado vector (or a list of hiccup vectors). If pretty-print? is set to false, compresses it as well. Then saves the compiled CSS to a given file path, if provided in the flags.

You can also call this function only with the hiccup vector, without any flags.

css-class clj/s

(css-class named)

Returns a keyword representing a CSS class. Accepts a keyword, a string or a symbol.

css-empty clj/s

CSS pseudoselector "css-empty". Used as a value, e.g.: [:.some-sel {:padding (px 20)} [css-empty {:padding (px 5)}]]

css-filter clj/s

(css-filter & args)

Coming soon

css-first clj/s

CSS pseudoselector "css-first". Used as a value, e.g.: [:.some-sel [css-first {:transform (scale 1.1)}]]

css-format clj/s≠

clj

(css-format arg)

cljs

(css-format arg)

(css-format arg & more)

A special function for @font-face.

css-id clj/s

(css-id named)

Returns a keyword representing a CSS id. Accepts a keyword, a string or a symbol.

css-max clj/s

(css-max & args)

Coming soon

css-min clj/s

(css-min & args)

Coming soon

css-not clj/s

(css-not arg)

Coming soon

css-rem clj/s

(css-rem value)

A relative length unit, "rem", depending on the size of the root element

css-var clj/s

(css-var & args)

Coming soon

cubic-bezier clj/s

(cubic-bezier & args)

Coming soon

darken clj/s

(darken color value)

Transforms a color to hsl/hsla and subtracts an absolute lightness from it. E.g.: (darken (rgb 50 100 150) "15%"), (darken :gray 0.35), (darken "#123456" (percent 50))

defattributeselector clj macro

(defattributeselector selector-name compiles-to)

Defines a CSS attribute selector. Those select all descendant elements containing a given attribute, of which the value matches a given substring. All attribute selectors have different conditions for matching: Start with a word, start with a substring, contain a word, contain a substring, end with a substring, have a given value, have a given attribute with any value.

By attributes, it is meant html attributes, e.g. span[class~="info"] selects all spans with a class containing a whole word "info". In tornado, we can represent this by (contains-word :span :class "info").

We can also use (contains-word :class "info") to mark all elements with that class ... compiles to [class~="info"] and affects all elements with that class (divs, spans, iframes, everything).

default clj/s

CSS pseudoselector "default". Used as a value, e.g.: [:.some-sel {:width (px 100)} [default {:width (px 120)}]]

defcombinatorselector clj macro

(defcombinatorselector selector-name compiles-to)

Defines a combinator selector function which describes relationships between its arguments depending on the selector type:

:#abc :.def is the default combinator selector - descendant selector. Affects all children with a class .def.

child-selector ">": is active when the given selectors are every of them a direct child of the previous one.

adjacent-sibling (selector) "+": is active when the given html blocks elements or elements with a given class/id connected with the "+" sign are adjacent siblings.

general-sibling (selector) "~" is active when the given selectors are on the same level of nesting; they do not have to be adjacent necessarily.

Usage: [:.abc [:.def (child-selector :p :#ghi)]] compiles to ".abc .def, .abc > p > #ghi"

defcssfn clj macro

(defcssfn fn-name)

(defcssfn fn-name css-fn-or-fn-tail)

(defcssfn clojure-fn-name compiles-to compile-fn)

Creates a CSS function which takes any number of arguments and creates a CSSFunction record for future compilation.

Defcssfn can take 1 argument, which creates the function with the same name in CSS and it will be expanded with str/join ", " (default function - comma-join): (defcssfn some-fn) => my.namespace/some-fn (some-fn "arg1" 42 (px 15)) ... compiles to "some-fn(arg1, 42, 15px)"

or it can take 2 arguments: (defcssfn css-min "min") => my.namespace/css-min (css-min (px 500) (vw 60)) ... compiles to "min(500px, 60vw)"

or the 2nd argument can be a compiling function (most commonly space-join, comma-join or single-arg for separating the args, you can also define a special function for that, but it should not ever be needed; read docs to these 3 functions): (defcssfn calc space-join) (calc (px 500) add 3 mul (vw 5)) ... "calc(500px + 3 * 5vw)"

you can also give defcssfn 3 arguments, where the 2nd one will be a special string for translation to CSS and the 3rd one the compiling function.

defkeyframes clj macro

(defkeyframes animation-name & frames)

Defines a CSS @keyframes animation. The animation name should have a unique symbol for later reference to it and then animation frames in a format [progress params]:

(defkeyframes fade-in-opacity [(percent 0) {:opacity 0}] [(percent 25) {:opacity 0.1}] [(percent 50) {:opacity 0.25}] [(percent 75) {:opacity 0.5}] [(percent 100) {:opacity 1}])

Then, insert it to the CSS hiccup list to make tornado compile it for later usage:

(def styles (list fade-in-opacity ...))

After that, you can assign this animation to whatever element you want:

(def styles (list fade-in-opacity [:.some-element {:animation-duration (ms 500) :animation-name fade-in-opacity}] [:#another-element {:animation-name fade-in-opacity :animation-delay (s 1.5)}]))

You can also define from & to progress animations:

(defkeyframes translate-animation [:from {:transform (translate (px 100) (px 200))}] [:to {:transform (translate (px 200) (px 400))}])

defpseudoclass clj macro

(defpseudoclass pseudoclass)

(defpseudoclass identifier css-pseudoclass)

Defines a CSS pseudoclass. A CSS pseudoclass can activate some CSS properties on a css-class/css-id/html-element based on some current special state of the element.

For example, hover: (defpseudoclass hover) When compiling a selectors sequence, e.g. [:.abc :#def hover], the resulting CSS selectors sequence will look like this: ".abc #def:hover".

So, what does it even do? We can give the element a special value on hover: ... [:a hover {:color :blue} ...] - when we hover over a link with our mouse, the text color of the link will turn blue until we put our mouse away.

Defpseudoclass can also take 2 parameters, where the 2nd one will be the translation to CSS to avoid collisions between Clojure and CSS - e.g.(defpseudolass css-empty "empty").

defpseudoclassfn clj macro

(defpseudoclassfn pseudoclass)

(defpseudoclassfn pseudoclass compiles-to)

Creates a special CSS pseudoclass function, which compiles similarly as a standard CSS pseudoclass, but it is pseudoclass function with an argument.

For example. if you wanted to only select every n-th argument: (defpseudoclassfn nth-child) (nth-child :odd) ... compiles to "<parent>:nth-child(odd)" (nth-child "3n+1") ... compiles to "<parent>:nth-child(3n+1)"

Or if you wanted to show something based on the current language of the browser: (defpseudoclass lang) (lang "en") ... compiles to "<parent>:lang(en)"

To avoid collisions with some Clojure functions, you can give a second argument to defpseudoclassfn for a different translation to CSS: (defpseudoclass css-not "not") (css-not :p) ... compiles-to "not(p)", which selects all descendants which are not a paragraph.

defpseudoelement clj macro

(defpseudoelement pseudoelement)

Defines a CSS pseudoelement. A CSS pseudoelement activates some CSS properties on a special part of a css-class/css-id/html-element.

For example, first-letter: (defpseudoclass first-letter) When compiling a selectors sequence, e.g. [:.abc :#def first-letter], the resulting CSS selectors sequence will look like this: ".abc #def::first-letter".

So, what does it even do? We can give the first letter of an element a special value: ... [:.abc :p first-letter {:font-size (px 60)} ...] - this causes the first letter of every paragraph in an element with class .abc to have the first letter significantly bigger than the rest of the paragraph.

defunit clj macro

(defunit unit)

(defunit identifier css-unit)

Creates a unit function which takes 1 argument and creates a CSSUnit record for future compilation. Defunit can take 1 arg: (defunit px) or 2 args: (defunit percent "%").

Usage of the defined units: (px 15) ... compiles to "15px" (percent 33) ... compiles to "33%"

CSSUnits can be added, subtracted, multiplied or divided by using function calc (you can also use these 4 keywords - they are defined just for better search in code: :add, :sub, :mul, :div

E.g. (calc (px 500) :add 3 :mul (vw 5)) ... "calc(500px + 3 * 5vw)".

deg clj/s

(deg value)

An angular unit, "degree".

desaturate clj/s

(desaturate color value)

Transforms a color to hsl/hsla and subtracts an absolute saturation from it. E.g.: (desaturate (rgb 50 100 150) "15%"), (desaturate :gray 0.35), (desaturate "#123456" (percent 50))

disabled clj/s

CSS pseudoselector "disabled". Used as a value, e.g.: [:.some-sel {:background-color :white} [disabled {:background-color :gray}]]

do-meta-alters! clj macro

(do-meta-alters!)

dpcm clj/s

(dpcm value)

A resolution unit, "dots per centimeter".

dpi clj/s

(dpi value)

A resolution unit, "dots per inches".

dppx clj/s

(dppx value)

A resolution unit, "dots per pixels".

drop-shadow clj/s

(drop-shadow & args)

Coming soon

ellipse clj/s

(ellipse & args)

Coming soon

em clj/s

(em value)

A relative length unit, "em", depending on the size of the parent element.

enabled clj/s

CSS pseudoselector "enabled". Used as a value, e.g.: [:.some-sel {:background-color :gray} [enabled {:background-color :white}]]

ends-with clj/s

(ends-with attribute subvalue)

(ends-with tag attribute subvalue)

Selects all descendant elements which have a given parameter with a value ending with a given substring. The substring does not have to be a whole matching word.

first-child clj/s

CSS pseudoselector "first-child". Used as a value, e.g.: [:.some-sel [first-child {:transform (scale 1.1)}]]

first-letter clj/s

Coming soon

first-line clj/s

Coming soon

first-of-type clj/s

CSS pseudoselector "first-of-type". Used as a value, e.g.: [:.some-sel [first-of-type {:transform (scale 1.1)}]]

focus clj/s

CSS pseudoselector "focus". Used as a value, e.g.: [:.some-sel [focus {:background-color :blue}]]

fr clj/s

(fr value)

A relative length unit, "fraction", depending on the size of the parent element.

fullscreen clj/s

CSS pseudoselector "fullscreen". Used as a value, e.g.: [:.some-sel [fullscreen {:background-color :gray}]]

general-sibling clj/s

(general-sibling & selectors)

Coming soon

grad clj/s

(grad value)

An angular unit, "gradian". 100 gradians are equal to 90 degrees.

grayscale clj/s≠

clj

(grayscale arg)

cljs

(grayscale arg)

(grayscale arg & more)

Coming soon

grid-areas clj/s

(grid-areas [first-row & more :as all-rows])

Given a sequence of grid-rows sequences, where each the element is represented by a keyword, a string or a symbol, return a grid-areas string:

(grid-areas [(repeat 3 :header) [:. :content :.] (repeat 3 :footer)]) Output CSS string: "header header header" ". content ." "footer footer footer"

has-attr clj/s

(has-attr attribute)

(has-attr tag attribute)

An attribute selector which selects all elements which have a given attribute with any value, or all html elements on/below the current nested selectors level which have a given attribute with any value.

has-val clj/s

(has-val attribute subvalue)

(has-val tag attribute subvalue)

Selects all descendants of a html tag which have a given parameter with a given value.

hover clj/s

CSS pseudoselector "hover". Used as a value, e.g.: [:.some-sel {:width (px 100)} [hover {:width (px 120)}]]

hsl clj/s

(hsl [hue saturation lightness])

(hsl hue saturation lightness)

Creates an hsl color.

hsla clj/s≠

clj

(hsla [hue saturation lightness])

(hsla [hue saturation lightness alpha])

(hsla hue saturation lightness)

(hsla hue saturation lightness alpha)

cljs

(hsla [hue saturation lightness alpha])

(hsla hue saturation lightness)

(hsla hue saturation lightness alpha)

Creates an hsla color.

html-style clj/s

(html-style styles-map)

Can be used for compilation of a map of style parameters to a single string of html style="..." attribute. Receives the styles map as its argument and returns a string of compiled style:

(html-style {:width (px 500) :height (percent 15) :color :font-black :background-color :teal})

=> "width:500px;height:15%;color:#1A1B1F;background-color:#008080"

hue-rotate clj/s≠

clj

(hue-rotate arg)

cljs

(hue-rotate arg)

(hue-rotate arg & more)

Coming soon

hwb clj/s

(hwb & args)

Coming soon

Hz clj/s

(Hz value)

A frequency unit, "Hertz.

image clj/s

(image & args)

Coming soon

important clj/s

(important expr)

After the expression is compiled, " !important" is appended to it:

(important [(repeat 3 :auto)]) => "auto auto auto !important" (important :none => "none !important" (important "yellow" => "yellow !important"

in clj/s

(in value)

An absolute length unit, "inch"

in-range clj/s

CSS pseudoselector "in-range". Used as a value, e.g.: [:.some-sel [in-range {:border [[(px 2) :solid :red]]}]]

indeterminate clj/s

CSS pseudoselector "indeterminate". Used as a value, e.g.: [:.some-sel {:width (px 100)} [indeterminate {:width (px 120)}]]

inset clj/s

(inset & args)

Coming soon

invalid clj/s

CSS pseudoselector "invalid". Used as a value, e.g.: [:.some-sel {:width (px 100)} [invalid [:.err-msg {:display :flex}]]]

invert clj/s≠

clj

(invert arg)

cljs

(invert arg)

(invert arg & more)

Coming soon

join clj/s

(join value)

(join unit-or-value & more-values)

A convenient function for simpler description of margin, padding or any similar CSS block which can can look like "1px 2px 3px 4px" after compilation. This function processes the input to create such a structure for much simpler description of the data.

Example usage:

(compile-expression (join 1 2 3)) ; is equal to [[(px 1) (px 2) (px 3)]] => "1px 2px 3px"

(compile-expression (join em 1 2 3)) ; is equal to [[(em 1) (em 2) (em 3)]] => "1em 2em 3em"

(compile-expression (join (em 3) 15 (fr 4) 3) ; is equal to [[(em 3) (px 15) (fr 4) (px 3)]] => "3em 15px 4fr 3px"

kHz clj/s

(kHz value)

A frequency unit, "kiloHertz.

lang clj/s

(lang arg)

Coming soon

last-child clj/s

CSS pseudoselector "last-child". Used as a value, e.g.: [:.some-sel [last-child {:padding-right 0}]]

last-of-type clj/s

CSS pseudoselector "last-of-type". Used as a value, e.g.: [:.some-sel [last-of-type {:margin-right (px 5p}]]

lh clj/s

(lh value)

A relative length unit, equal to the line height.

lighten clj/s

(lighten color value)

Transforms a color to hsl/hsla and adds an absolute lightness to it. E.g.: (lighten (rgb 50 100 150) "15%"), (lighten :gray 0.35), (lighten "#123456" (percent 50))

linear-gradient clj/s

(linear-gradient & args)

Coming soon

links clj/s

CSS pseudoselector "links". Used as a value, e.g.: [:.some-sel [hover {:color :font-black}]]

marker clj/s

Coming soon

matrix clj/s

(matrix & args)

Coming soon

matrix3d clj/s

(matrix3d & args)

Coming soon

mix-colors clj/s

(mix-colors color & more)

Given any number of colors in any form (alpha-hex, non-alpha-hex, rgb, rgba, hsl, hsla), converts them to the most frequent type and mixes them.

mm clj/s

(mm value)

An absolute length unit, "millimeter".

ms clj/s

(ms value)

A time unit, "millisecond".

nth-child clj/s

(nth-child arg)

Coming soon

nth-last-child clj/s

(nth-last-child arg)

Coming soon

nth-last-of-type clj/s

(nth-last-of-type arg)

Coming soon

nth-of-type clj/s

(nth-of-type arg)

Coming soon

only-child clj/s

CSS pseudoselector "only-child". Used as a value, e.g.: [:.some-sel {:padding (px 10)} [only-child {:padding (px 15)}]]

only-of-type clj/s

CSS pseudoselector "only-of-type". Used as a value, e.g.: [:.some-sel [only-of-type {:background-color :chocolate}]]

opacify clj/s

(opacify color value)

Transforms a color to its with-alpha form and adds an absolute alpha to it. E.g.: (opacify(rgb 50 100 150) "15%"), (opacify :gray 0.35), (opacify "#123456" (percent 50))

opposite-hue clj/s

(opposite-hue color)

Transforms a color to hsl/hsla and rotates its hue by a half.

optional clj/s

CSS pseudoselector "optional". Used as a value, e.g.: [:.some-sel [optional {:opacity 0.8}]]

out-of-range clj/s

CSS pseudoselector "out-of-range". Used as a value, e.g.: [:.some-sel [out-of-range {:display :none}]]

pc clj/s

(pc value)

An absolute length unit, "pica".

percent clj/s

(percent value)

An absolute length unit, "percent" ("%"), can also be used as color alpha or in defining keyframes in this library.

perspective clj/s≠

clj

(perspective arg)

cljs

(perspective arg)

(perspective arg & more)

Coming soon

polygon clj/s

(polygon & args)

Coming soon

pt clj/s

(pt value)

An absolute length unit, "point".

px clj/s

(px value)

An absolute length unit, "pixel".

rad clj/s

(rad value)

An angular unit, "radian". Equal to 360°/2π

radial-gradient clj/s

(radial-gradient & args)

Coming soon

read-only clj/s

CSS pseudoselector "read-only". Used as a value, e.g.: [:.some-sel [read-only {:background-color :blanchedalmond}]]

read-write clj/s

CSS pseudoselector "read-write". Used as a value, e.g.: [:.some-sel [read-write {:cursor :pointer}]]

repeating-linear-gradient clj/s

(repeating-linear-gradient & args)

Coming soon

repeating-radial-gradient clj/s

(repeating-radial-gradient & args)

Coming soon

repl-css clj/s

(repl-css css-hiccup)

Generates CSS from a standard Tornado hiccup vector (or a list of hiccup vectors) and pretty prints the output CSS string, which is useful for evaluating any tornado code in the REPL.

required clj/s

CSS pseudoselector "required". Used as a value, e.g.: [:.some-sel [required {:border [[(px 2) :dotted :crimson]]}]]

rgb clj/s

(rgb [red green blue])

(rgb red green blue)

Creates an rgb color.

rgba clj/s≠

clj

(rgba [hue saturation lightness])

(rgba [red green blue alpha])

(rgba red green blue)

(rgba red green blue alpha)

cljs

(rgba [red green blue alpha])

(rgba red green blue)

(rgba red green blue alpha)

Creates an rgba color.

root clj/s

CSS pseudoselector "root". Used as a value, e.g.: [:.some-sel [root {:font-size (px 24)}]]

rotate clj/s≠

clj

(rotate arg)

cljs

(rotate arg)

(rotate arg & more)

Coming soon

rotate-hue clj/s

(rotate-hue color angle)

Transforms a color to hsl/hsla and rotates its hue by an angle.

rotate3d clj/s

(rotate3d & args)

Coming soon

rotateX clj/s≠

clj

(rotateX arg)

cljs

(rotateX arg)

(rotateX arg & more)

Coming soon

rotateY clj/s≠

clj

(rotateY arg)

cljs

(rotateY arg)

(rotateY arg & more)

Coming soon

rotateZ clj/s≠

clj

(rotateZ arg)

cljs

(rotateZ arg)

(rotateZ arg & more)

Coming soon

s clj/s

(s value)

A time unit, "second".

saturate clj/s

(saturate color value)

Transforms a color to hsl/hsla and adds an absolute saturation to it. E.g.: (saturate (rgb 50 100 150) "15%"), (saturate :gray 0.35), (saturate "#123456" (percent 50))

scale clj/s

(scale & args)

Coming soon

scale-alpha clj/s

(scale-alpha color value)

Transforms a color to its with-alpha form and adds multiplies its alpha with a numeric value. E.g.: (scale-alpha (rgb 50 100 150) "15%"), (scale-alpha :gray 0.35), (scale-alpha "#123456" (percent 50))

scale-lightness clj/s

(scale-lightness color value)

Transforms a color to hsl/hsla and adds multiplies its lightness with a numeric value. E.g.: (scale-lightness (rgb 50 100 150) "15%"), (scale-lightness :gray 0.35), (scale-lightness "#123456" (percent 50))

scale-saturation clj/s

(scale-saturation color value)

Transforms a color to hsl/hsla and adds multiplies its saturation with a numeric value. E.g.: (saturate (rgb 50 100 150) "15%"), (saturate :gray 0.35), (saturate "#123456" (percent 50))

scale3d clj/s

(scale3d & args)

Coming soon

scaleX clj/s≠

clj

(scaleX arg)

cljs

(scaleX arg)

(scaleX arg & more)

Coming soon

scaleY clj/s≠

clj

(scaleY arg)

cljs

(scaleY arg)

(scaleY arg & more)

Coming soon

scaleZ clj/s≠

clj

(scaleZ arg)

cljs

(scaleZ arg)

(scaleZ arg & more)

Coming soon

scope clj/s

CSS pseudoselector "scope". Used as a value, e.g.: [:.some-sel [scope {:background-color :lime}]]

selection clj/s

Coming soon

sepia clj/s≠

clj

(sepia arg)

cljs

(sepia arg)

(sepia arg & more)

Coming soon

single-arg clj/s≠

clj

(single-arg arg)

cljs

(single-arg arg)

(single-arg arg & more)

Coming soon

skew clj/s

(skew & args)

Coming soon

skewX clj/s≠

clj

(skewX arg)

cljs

(skewX arg)

(skewX arg & more)

Coming soon

skewY clj/s≠

clj

(skewY arg)

cljs

(skewY arg)

(skewY arg & more)

Coming soon

space-join clj/s

(space-join & args)

Coming soon

starts-with clj/s

(starts-with attribute subvalue)

(starts-with tag attribute subvalue)

Selects all descendant elements which have a given parameter with a value starting with a given substring (unlike the contains-word selector, the substring does not have to be a whole matching word.

starts-with-word clj/s

(starts-with-word attribute subvalue)

(starts-with-word tag attribute subvalue)

Selects all descendant elements which have a given parameter with a value starting with a given word (substring is not enough - a matching word separated by commas or spaces).

symbols clj/s

(symbols & args)

Coming soon

target clj/s

CSS pseudoselector "target". Used as a value, e.g.: [:.some-sel [target {:background-color :teal}]]

translate clj/s

(translate & args)

Coming soon

translate3d clj/s

(translate3d & args)

Coming soon

translateX clj/s≠

clj

(translateX arg)

cljs

(translateX arg)

(translateX arg & more)

Coming soon

translateY clj/s≠

clj

(translateY arg)

cljs

(translateY arg)

(translateY arg & more)

Coming soon

translateZ clj/s≠

clj

(translateZ arg)

cljs

(translateZ arg)

(translateZ arg & more)

Coming soon

transparentize clj/s

(transparentize color value)

Transforms a color to its with-alpha form and subtracts an absolute alpha from it. E.g.: (transparentize (rgb 50 100 150) "15%"), (transparentize :gray 0.35), (transparentize "#123456" (percent 50))

triad-next clj/s

(triad-next color)

Transforms a color to hsl/hsla and rotates its hue by a third clockwise.

triad-previous clj/s

(triad-previous color)

Transforms a color to hsl/hsla and rotates its hue by a third counterclockwise.

turn clj/s

(turn value)

An angular unit, "turn". Represents one whole turn, equal to 360 degrees.

url clj/s

(url & args)

Coming soon

valid clj/s

CSS pseudoselector "valid". Used as a value, e.g.: [:.some-sel [valid {:background-color :limegreen}]]

vh clj/s

(vh value)

A relative length unit, "viewport height", based on the height of the window.

visited clj/s

CSS pseudoselector "visited". Used as a value, e.g.: [:.some-sel [visited {:color :seashell}]]

vmax clj/s

(vmax value)

A relative length unit, maximum of vw and vh.

vmin clj/s

(vmin value)

A relative length unit, minimum of vw and vh.

vw clj/s

(vw value)

A relative length unit, "viewport width", based on the width of the window.

with-alpha clj/s

(with-alpha color alpha)

Given a color, sets its alpha to a given value. E.g.: (with-alpha :red 0.4), (with-alpha "#FF7FCF" 0.4)

with-hue clj/s

(with-hue color hue)

Given a color, transforms it into HSL and sets its hue to a given value. E.g.: (with-hue :red 150), (with-hue (rgba 200 150 100 0.3) 75)

with-lightness clj/s

(with-lightness color lightness)

Given a color, transforms it into HSL and sets its lightness to a given value. E.g.: (with-lightness :red 0.8), (with-lightness (rgba 200 150 100 0.3) 0.8)

with-saturation clj/s

(with-saturation color saturation)

Given a color, transforms it into HSL and sets its saturation to a given value. E.g.: (with-saturation :red 0.5), (with-saturation (rgba 200 150 100 0.3) 0.5)