charge - v1.0.0

charge

Types

Asset

opaque </> 
pub opaque type Asset

HTMLFile

</> 
pub type HTMLFile {
  HTMLFile(
    source: option.Option(@internal Path),
    path: @internal SitePath,
    html: element.ElementTree,
  )
}

Constructors

Loaded

opaque </> 
pub opaque type Loaded(page, aggregate)

Pipeline

opaque </>

load -> process -> persist

pub opaque type Pipeline(state, aggregate)

Rendered

</> 
pub type Rendered =
  List(Asset)

Values

asset_to_readable_string

</> 
pub fn asset_to_readable_string(asset: Asset) -> String

assets_to_readable_string

</> 
pub fn assets_to_readable_string(assets: List(Asset)) -> String

derived_html_file

</> 
pub fn derived_html_file(
  source: @internal Path,
  path: @internal SitePath,
  rendered: element.ElementTree,
) -> Asset

find_asset

</> 
pub fn find_asset(
  assets: List(Asset),
  path: @internal SitePath,
) -> Result(Asset, Nil)

generated_html_file

</> 
pub fn generated_html_file(
  path: @internal SitePath,
  rendered: element.ElementTree,
) -> Asset

if_html

</> 
pub fn if_html(
  asset: Asset,
  or_else: a,
  f: fn(HTMLFile) -> a,
) -> a

loaded

</> 
pub fn loaded(
  pages pages: List(page),
  aggregate aggregate: aggregate,
) -> Loaded(page, aggregate)

new

</> 
pub fn new(
  out out_dir: @internal Path,
  load load: fn() -> Result(
    Loaded(state, aggregate),
    error.ChargeError,
  ),
  render render: fn(List(state), aggregate) -> Result(
    List(Asset),
    error.ChargeError,
  ),
) -> Pipeline(state, aggregate)

run

</> 
pub fn run(
  pipeline: Pipeline(page, aggregate),
) -> promise.Promise(Result(List(Asset), error.ChargeError))

Cleans the output directory and runs the pipeline

sort_assets

</> 
pub fn sort_assets(assets: List(Asset)) -> List(Asset)

text_file

</> 
pub fn text_file(
  path: @internal SitePath,
  content: String,
) -> Asset

with

</> 
pub fn with(
  from: Pipeline(page, aggregate),
  render: fn(aggregate) -> Result(List(Asset), error.ChargeError),
) -> Pipeline(page, aggregate)

with_asset

</> 
pub fn with_asset(
  from: Pipeline(page, aggregate),
  render: fn(aggregate) -> Result(Asset, error.ChargeError),
) -> Pipeline(page, aggregate)

Derive an asset from the pipeline aggregate

with_assets

</> 
pub fn with_assets(
  from: Pipeline(page, aggregate),
  render: fn(aggregate) -> Result(List(Asset), error.ChargeError),
) -> Pipeline(page, aggregate)

Derive some assets from the pipeline aggregate

with_async

</> 
pub fn with_async(
  from: Pipeline(page, aggregate),
  render: fn(aggregate) -> promise.Promise(
    Result(List(Asset), error.ChargeError),
  ),
) -> Pipeline(page, aggregate)

The raw unit for composing sync rendering pipelines

with_async_component

</> 
pub fn with_async_component(
  from: Pipeline(state, aggregate),
  comp: #(
    String,
    fn(component.RenderData, element.ElementTree) -> promise.Promise(
      Result(element.ElementTree, error.ChargeError),
    ),
  ),
) -> Pipeline(state, aggregate)

with_components

</> 
pub fn with_components(
  from: Pipeline(page, aggregate),
  comps: List(
    #(
      String,
      fn(component.RenderData, element.ElementTree) -> Result(
        element.ElementTree,
        error.ChargeError,
      ),
    ),
  ),
) -> Pipeline(page, aggregate)

Add server-side components to the pipeline

with_derived_assets

</> 
pub fn with_derived_assets(
  from: Pipeline(page, aggregate),
  extract: fn(Asset) -> Result(List(Asset), error.ChargeError),
) -> Pipeline(page, aggregate)

Add assets that are derived from an existing asset, e.g. providing an alternate of each page

with_static_dir

</> 
pub fn with_static_dir(
  pipeline: Pipeline(page, aggregate),
  dir: @internal Path,
) -> Pipeline(page, aggregate)

Add a static directory to be copied as part of the pipeline

with_summary

</> 
pub fn with_summary(
  from: Pipeline(state, aggregate),
  summarize: fn(List(Asset), aggregate) -> Result(
    List(Asset),
    error.ChargeError,
  ),
) -> Pipeline(state, aggregate)

Add some generic tasks into the pipeline given all the assets rendered till this point as well as the relevant aggregate e.g. running creating an accessibility report on all generated html pages, creating an RSS Feed, etc.

✨ Search Document