Sketch

Sketch is a module providing CSS-in-Gleam in its simpler form. Sketch does not try to add complicated API on top of CSS. If you have CSS knowledge, you’ll feel right at home, with all the niceties offered by Sketch, i.e. type-checking of sizes and push-to-browser stylesheets of your classes, as well as SSR support.

Sketch supports both runtime of Gleam, and will let you write your CSS without over-thinking about it. Let Sketch handle the hard task for you of CSS caching, generation and pushing it in the browser. Sketch do the right choices for you, to maximise performance in the browser and on BEAM.

Distributions

Sketch is thought as bare package, built as a foundation for every CSS packages that want to leverage it. In the Sketch package, you’ll find all CSS properties accessible, as well as low level generation functions, to go from Sketch to CSS. Sketch package is also made for framework developers, to provide a common basement, reusable across the entire Gleam ecosystem, letting users reuse their knowledge no matter what they are coding.

Sketch already supports two compilation target: Lustre, with sketch_lustre, and pure CSS generation à la CSS Modules, with sketch_css. As a user, you want to grab one of those package, and start building! Both targets can be mixed too, to reach whoever you want! For framework authors, let’s see you at integration part!

Installation

Sketch is published on Hex. Add it to your project by using the gleam CLI.

# For Lustre integration
gleam add sketch sketch_lustre
# For CSS generation
gleam add sketch sketch_css

Core concept

Sketch focuses on the concept of generating CSS in a performant way. To do it, Sketch needs to use a cache. The cache allows to avoid repeating unneeded computations, and ensure consistency across repaints. Because the browser likes static CSS, using a cache make sure the browser will not undergo unneeded computations to recompute styles at every repaint.

Sketch Lustre

Setup

If you’re using Lustre (which is strongly recommended), sketch_lustre got you. sketch_lustre exposes one entrypoint, sketch/lustre, containing everything needed to get started.

// main.gleam
import lustre
import sketch
import sketch/lustre as sketch_lustre

pub fn main() {
  // Initialise the cache. Two strategies can be used. Ephemeral caches are designed as throw-away caches.
  let assert Ok(cache) = sketch.cache(strategy: sketch.Ephemeral)
  // Select the output of the generated stylesheet.
  sketch_lustre.node()
  // Add the sketch CSS generation "view middleware".
  |> sketch_lustre.compose(view, cache)
  // Give the new view function to lustre runtime!
  |> lustre.simple(init, update, _)
  // And voilà!
  |> lustre.start("#app", Nil)
}

Usage

sketch_lustre exposes two modules to help you build your site, similarly to Lustre: sketch/lustre/element and sketch/lustre/element/html. The first one let you use raw element generation and exposes the Sketch Lustre Element(msg) type, that can be used (almost) interchangeably with Lustre, and element helpers, i.e. element, fragment, or even keyed.

Because a sketch_lustre view function expects an sketch/lustre/element.Element(msg) to paint, you should now write all your view functions to return Sketch elements. All Sketch elements can be instanciated with element, or with the corresponding sketch/lustre/element/html.element. An element accepts the same thing as a Lustre element, but includes a sketch.Class value as first argument. That class will be applied to the final generated element.

NB: all elements can be generated using the correct function, or using its “underscored” version. In the second case, Sketch Lustre behaves exactly like Lustre, and will not add another class. This is helpful when you want to use a simple node, without any class linked on it.

import sketch
import sketch/lustre/element
import sketch/lustre/element/html
import sketch/size.{px}

fn main_style() {
  sketch.class([
    sketch.background("red"),
    sketch.font_size(px(16)),
  ])
}

fn view(model: Int) {
  html.div(main_style(), [], [
    html.div_([], [h.text(int.to_string(model))]),
  ])
}

And you’re done! Enjoy your Lustre app, Sketch-enhanced!

Final notes

On Sketch Lustre Element

A Sketch Element(msg) is extremely similar to a Lustre Element(msg), excepted it carries styles information on top. Going from a sketch/lustre/element.Element(msg) to a lustre/element.Element(msg) is straightforward, by using sketch/lustre/element.unstyled. The opposite (going from a Lustre element to a Sketch Lustre element) is also possible by using sketch/lustre/element.styled!

Usage with Shadow DOM

In browser, Sketch can work with a Shadow DOM, in order to hide the compiled styles from the rest of the application. To do it, you can use plinth. This allows to create a ShadowRoot, to use sketch/options.shadow_root(). In the same way you can initialize the cache to render in document or in a style node, you can now use a Shadow Root to paint styles in your application!

Sketch Redraw

Setup

When you’re using Redraw, sketch_redraw covers you. sketch_redraw exposes one entrypoint, sketch/redraw, containing everything needed to get started.

// main.gleam
import redraw
import sketch
import sketch/redraw as sketch_redraw

pub fn main() {
  let root = client.create_root("root")
  client.render(root, redraw.strict_mode([
    // Initialise the cache. Sketch Redraw handles the details for you.
    sr.provider([
      // Here comes your components!
    ])
  ]))
}

Usage

sketch_redraw exposes one module to help you build your site, similarly to redraw: sketch/redraw/html. html is simply a supercharged component, accepting a sketch.Class as first argument, and applies that style to the node. Because it’s a simple component, sketch/redraw/html and redraw/html can be mixed in the same code without issue! Because of that property, sketch_redraw does not expose text and none function at that time.

import redraw/html as h
import sketch
import sketch/redraw/html
import sketch/size.{px}

fn main_style() {
  sketch.class([
    sketch.background("red"),
    sketch.font_size(px(16)),
  ])
}

fn view(model: Int) {
  html.div(main_style(), [], [
    h.div([], [
      h.text(int.to_string(model))
    ]),
  ])
}

And you’re done! Enjoy your Redraw app, Sketch-enhanced!

Final notes

Sketch Redraw tries to integrate nicely with React Devtools! In case you’re seeing something weird, signal the bug!

Sketch CSS

Because pure CSS generation is straightforward, sketch_css does not need a cache to generate correct CSS files. Instead, sketch_css ships with a CLI tool, able to read your Gleam styles files, and output corresponding your CSS automagically, while providing an abstraction layer written in Gleam, to make sure you’re using the right classes! It’s an other way to leverage Sketch core and enjoy the styling in Gleam, while taking advantage of all the static CSS power!

To run the generator, you have to use the command gleam run -m sketch/css generate at the root of your project. By default, sketch_css will try to read all files named *_styles.gleam, *_css.gleam and *_sketch.gleam in your src folder, no matter where they are. You can put them at root, nested, or in a folder called css, sketch_css does not care! After fetching the styles files, sketch_css will output your generated CSS files in a styles folder, at the root of the project. They can then be served in the way you want. In the same time, sketch_css will output Gleam interfaces in src/sketch/styles, matching your styles files, to use in your project!

Options

Sketch CSS generation has strong defaults, but everything can be customised. Use the CLI flags to configure what you need. CLI exposes 3 flags:

• --dest, accepting a folder, relative to current directory. It defaults to styles
• --src, accepting a folder, relative to current directory. It defaults to src.
• --interface, accepting a folder, relative to current directory. It defaults to src/sketch/styles.

A note on generation algorithm

Because a Sketch Class can be generated in multiple ways, and with variable, Sketch CSS takes that into account. Every simple Sketch Class will be iso generated in CSS, but every Sketch Class that contains variable will be generated with the variable taken into account! Sketch CSS being opinionated, it generates the class, with a CSS variable, letting you update it, override it, etc.

All _ are also automatically transformed into -, because CSS classes are most of the time used with dashes, so Sketch CSS follows that convention!

Example

// src/main_styles.gleam
import sketch

fn flexer() {
  sketch.class([
    sketch.display("flex"),
  ])
}

fn flexer_direction(flex_direction: String) {
  sketch.class([
    sketch.compose(flexer()),
    sketch.flex_direction(flex_direction),
  ])
}

/* styles/main_styles.css */
.flexer {
  display: flex;
}

.flexer-direction {
  flex-direction: var(--flex-direction);
}

// src/sketch/styles/main_styles.gleam
pub const flexer = "flexer"

pub const flexer_direction = "flexer flexer-direction"

Sketch general usage

At its core, Sketch relies on sketch.class, which let you define a class. A class is made of CSS properties. All of those can be accessed in sketch module. Build your classes, and use them across your codebase!

Using media queries and pseudo-selectors

Because we’re building CSS, we can leverage its full power, contrarily to inline styling. This mean we can use media queries and pseudo-selectors! You only need to call the proper functions, and Sketch will take care of the rest.

import sketch
import sketch/media
import sketch/size.{px}

fn my_class() {
  sketch.class([
    sketch.display("flex"),
    sketch.flex_direction("row"),
    sketch.background("red"),
    sketch.hover([
      sketch.background("blue"),
    ]),
    sketch.media(media.max_width(px(320)), [
      sketch.flex_direction("column"),
      sketch.hover([
        sketch.background("green"),
      ]),
    ]),
  ])
}

The example above will be compiled to the following CSS.

.my-class {
  display: flex;
  flex-direction: row;
  background: red;
}

.my-class:hover {
  background: blue;
}

@media (max-width: 320px) {
  .my-class {
    flex-direction: column;
  }

  .my-class:hover {
    background: green;
  }
}

Composition

Because we oftentimes need to compose CSS classes, Sketch provides a compose function. This allow you to reuse CSS properties from another class, without having the burden of copy-pasting the styles, or having to think on the class names to put in your nodes! Of course, this remains totally optional. An example:

fn button_style() {
  sketch.class([
    sketch.appearance("none"),
    sketch.border("none"),
    sketch.border_radius(px(10)),
    sketch.transition("all .2s"),
  ])
}

fn enabled_button_style() {
  sketch.class([
    sketch.compose(button_style()),
    sketch.background("red"),
    sketch.color("white"),
  ])
}

fn disabled_button_style() {
  sketch.class([
    sketch.compose(button_style()),
    sketch.background("grey"),
    sketch.color("black"),
  ])
}

fn button(disabled) {
  let class = case disabled {
    True -> disabled_button_style()
    False -> enabled_button_style()
  }
  html.button(class, [], [html.text("Yay!")])
}

Some opinions on properties

A lot of properties are accessible directly through the sketch package. But with time, some could be added, and new features for existing properties can appear. That’s why Sketch will never try to be on your way: at any time you can access property(), which allows you to push any arbitrary property in a class. Another thing is that Sketch will always let you access raw, low-level properties. If you’re trying to use something like sketch.width("auto") and the property does not support String, look for a variant with an underscore (_), it should fullfill your needs, like sketch.width_("auto")! In case something is missing or a property does not have its underscore alternative, open an issue — or better, a PR — on the repo!

Integration

This part is new, and subject to modification. Because nobody integrated Sketch in their framework yet, it’s hard to write a correct guide, that is useful and not redundant. If you’re in the case of writing a framework binding, please, let’s keep in touch directly, and I’ll help you integrate Sketch. That would be immensely helpful, to write a correct guide after this! Meanwhile, you can find necessary pointers below to help you get started by yourself!

If you’re here, it means you’re interested in integrating Sketch in your framework! What a wonderful idea!

To integrate Sketch in your framework, you have 2 choices:

• run Sketch in your repaint function.
• compiles all Sketch files as static code.

To run Sketch in your repaint function, your only need is to run sketch.class_name on a sketch.Class. Let your users write sketch.Class, and then, do the hard work of wiring everything up by calling sketch.class_name. This requires a sketch.Cache to run correctly. Take a look at what is happening in sketch_lustre to figure out how everything works.

A nice way is also to precompile everything, like sketch_css is doing. Instead of generating the CSS on-the-fly, which browsers does not really like, you can precompute everything. By using a Gleam parser, like glance, you could compile everything to plain CSS. This area is subject of exploration, and is the way sketch_lustre tries to follow in some specific environments, like Vite and Lustre Dev tools. If you’re interested in the subject, let’s keep in touch!