css 0.1.0 · OCaml Package

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 * 'a

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 ->
  'b

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 ->
  'b

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 ->
  'b

val margin : 
  root:t ->
  parent:'a ->
  t ->
  [> `Length of
       T.number
       * [> `In | `cm | `em | `ex | `mm | `pc | `pt | `px | `q | `rem ] ] as 'b ->
  'b

val padding : 
  root:t ->
  parent:'a ->
  t ->
  [> `Length of
       T.number
       * [> `In | `cm | `em | `ex | `mm | `pc | `pt | `px | `q | `rem ] ] as 'b ->
  'b

val vertical_align : 
  root:t ->
  parent:'a ->
  t ->
  [> `Length of
       T.number
       * [> `In | `cm | `em | `ex | `mm | `pc | `pt | `px | `q | `rem ] ] as 'b ->
  'b

Associating computation functions to properties

type binding =

| B : 'a P.prop * (root:t -> parent:t -> t -> 'a P.value -> t) -> binding

val comp : 
  (root:'a -> parent:t -> t -> 'b -> 'b) ->
  'b P.prop ->
  root:'a ->
  parent:t ->
  t ->
  'b 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 -> 'd

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 -> 'a -> 'a) ->
  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.

package css

Mapping properties to values

Computing functions

Associating computation functions to properties

Computing from declarations