package css

  1. Overview
  2. Docs

Computing values.

Mapping properties to values

module Computed : sig ... end

A Computed.t maps a 'a property to a value of type 'a, if any.

type t = Computed.t
val opt : t -> 'a P.prop -> 'a option

opt t p returns the computed value of p in t, if any.

val get : t -> 'a P.prop -> 'a

opt t p returns the computed value of p in t if present or else returns the initial value of p.

val add : t -> 'a P.prop -> 'a -> t

add t p v adds binding from p to v in t.

val filter_inherited : t -> t

filter_inherited t returns bindings of t where the property is inherited.

val empty : t
val pp : Stdlib.Format.formatter -> t -> unit
val comp_global : parent:t -> 'a P.prop -> T.global_kw -> 'a

comp_global ~parent p v returns value of p according to global value v, i.e. it returns the initial value of p, of the value of p in parent.

val get_p : parent:t -> t -> 'a P.prop -> 'a

get_p ~parent t p returns value of p in t. If p is not mapped in t and p is not inherited, returns initial value of p. If p is inherited, returns its value in parent. If p is not mapped in parent, returns initial value of p.

Computing functions

val to_px : T.number -> T.abs_length_unit -> float
val px_of_font_size_kw : (T.font_size -> float) Stdlib.ref
val color : root:'a -> parent:t -> 'b -> T.color -> T.color
val accent_color : root:'a -> parent:t -> 'b -> [< `Auto | `Current_color | `Named_color of string | `Rgba of float * float * float * float | `System_color of T.system_color | `Transparent ] -> T.accent_color
val length_of_font_size : t -> float -> [> `em | `ex | `rem ] -> float option
val length : root:t -> t -> T.number -> [> `In | `cm | `em | `ex | `mm | `pc | `pt | `px | `q | `rem ] as 'a -> T.number * 'b
val font_size : root:t -> parent:t -> 'a -> T.font_size -> T.font_size

Computes font_size in px when possible from absolute size or size relative to parent.

val font_weight : root:'a -> parent:t -> 'b -> T.font_weight -> T.font_weight
val size : root:t -> parent:'a -> t -> [> `Length of T.number * [> `In | `cm | `em | `ex | `mm | `pc | `pt | `px | `q | `rem ] ] as 'b -> 'c
val line_height : root:t -> parent:'a -> t -> [< T.line_height ] -> [> T.line_height ]
val word_spacing : root:t -> parent:'a -> t -> [< T.word_spacing ] -> [> T.word_spacing ]
val border_width_of_kw : (T.border_width_kw -> float) Stdlib.ref
val border_width : root:t -> parent:'a -> t -> [> `Length of T.number * [> `In | `cm | `em | `ex | `mm | `pc | `pt | `px | `q | `rem ] | `Medium | `Thick | `Thin ] as 'b -> 'c
val font_family_of_generic : (T.font_family_generic_kw -> string) Stdlib.ref
val font_family_ : root:'a -> parent:'b -> 'c -> [< T.font_family_ ] -> [> T.font_family_ ]
val font_family : root:'a -> parent:'b -> 'c -> [< T.font_family_ ] list -> [> T.font_family_ ] list
val max_size : root:t -> parent:'a -> t -> [> `Length of T.number * [> `In | `cm | `em | `ex | `mm | `pc | `pt | `px | `q | `rem ] ] as 'b -> 'c
val margin : root:t -> parent:'a -> t -> [> `Length of T.number * [> `In | `cm | `em | `ex | `mm | `pc | `pt | `px | `q | `rem ] ] as 'b -> 'c
val padding : root:t -> parent:'a -> t -> [> `Length of T.number * [> `In | `cm | `em | `ex | `mm | `pc | `pt | `px | `q | `rem ] ] as 'b -> 'c
val vertical_align : root:t -> parent:'a -> t -> [> `Length of T.number * [> `In | `cm | `em | `ex | `mm | `pc | `pt | `px | `q | `rem ] ] as 'b -> 'c

Associating computation functions to properties

type binding =
  1. | B : 'a P.prop * (root:t -> parent:t -> t -> 'a P.value -> t) -> binding
val comp : (root:'a -> parent:t -> t -> 'b -> 'c) -> 'd P.prop -> root:'e -> parent:t -> t -> 'f P.value -> Computed.binding P.M.t

comp f p ~root ~parent t v computes value of property p from its parsed value v, in the context of root and parent maps. f is applied on:

  • the result of recursive expansion if v is a variable,
  • the result of comp_global if v is a global keyword,
  • else v.

The resulting computed value is then added to t for property p.

val map : root:'a -> parent:'b -> 'c -> 'd -> 'e

map ~root ~parent t v returns v, without any computation. This is the default computation for several properties.

val register_prop_fun : 'a P.prop -> (root:t -> parent:t -> t -> 'b -> 'b) -> unit

register_prop_fun p f registers f as computation function for values of property p. This can be used to override or specify the computation function of a property.

Computing from declarations

val compute_decl : root:t -> parent:t -> t -> P.binding -> t
val compute_decls : root:t -> parent:t -> t -> P.binding list -> t

compute_decls ~root ~parent t decls performs computations of the given declarations decls in the environment of root computed values, parent computed values and current computed values t.