sprocket/context

Types

AbstractFunctionalComponent

pub type AbstractFunctionalComponent =
  fn(Context, Dynamic) -> #(Context, Element)

Attribute

</>

pub type Attribute {
  Attribute(name: String, value: Dynamic)
  Event(name: String, handler: IdentifiableHandler)
  ClientHook(id: Unique, name: String)
}

Constructors

```
Attribute(name: String, value: Dynamic)
```

Event(name: String, handler: IdentifiableHandler)

```
ClientHook(id: Unique, name: String)
```

CallbackResult

</>

pub type CallbackResult {
  CallbackResult(deps: Option(HookDependencies))
}

Constructors

CallbackResult(deps: Option(HookDependencies))

ClientDispatcher

</>

pub type ClientDispatcher =
  fn(String, Option(String)) -> Result(Nil, Nil)

ClientEventHandler

</>

pub type ClientEventHandler =
  fn(String, Option(Dynamic), ClientDispatcher) -> Nil

Compared

</>

pub type Compared(a) {
  Changed(changed: a)
  Unchanged
}

Constructors

```
Changed(changed: a)
```
```
Unchanged
```

ComponentHooks

</>

pub type ComponentHooks =
  OrderedMap(Int, Hook)

ComponentWip

</>

pub type ComponentWip {
  ComponentWip(
    hooks: ComponentHooks,
    index: Int,
    is_first_render: Bool,
  )
}

Constructors

ComponentWip(
  hooks: ComponentHooks,
  index: Int,
  is_first_render: Bool,
)

Context

</>

pub type Context {
  Context(
    view: Element,
    wip: ComponentWip,
    handlers: List(IdentifiableHandler),
    render_update: fn() -> Nil,
    update_hook: fn(Unique, fn(Hook) -> Hook) -> Nil,
    dispatch_event: fn(Unique, String, Option(String)) ->
      Result(Nil, Nil),
    cuid_channel: Subject(cuid.Message),
    providers: Dict(String, Dynamic),
  )
}

Constructors

Context(
  view: Element,
  wip: ComponentWip,
  handlers: List(IdentifiableHandler),
  render_update: fn() -> Nil,
  update_hook: fn(Unique, fn(Hook) -> Hook) -> Nil,
  dispatch_event: fn(Unique, String, Option(String)) ->
    Result(Nil, Nil),
  cuid_channel: Subject(cuid.Message),
  providers: Dict(String, Dynamic),
)

Dispatcher

</>

pub type Dispatcher {
  Dispatcher(
    dispatch: fn(String, String, Option(String)) ->
      Result(Nil, Nil),
  )
}

Constructors

Dispatcher(
  dispatch: fn(String, String, Option(String)) ->
    Result(Nil, Nil),
)

EffectCleanup

</>

pub type EffectCleanup =
  Option(fn() -> Nil)

EffectResult

</>

pub type EffectResult {
  EffectResult(
    cleanup: EffectCleanup,
    deps: Option(HookDependencies),
  )
}

Constructors

EffectResult(
  cleanup: EffectCleanup,
  deps: Option(HookDependencies),
)

Element

</>

pub type Element {
  Element(
    tag: String,
    attrs: List(Attribute),
    children: List(Element),
  )
  Component(
    component: FunctionalComponent(Dynamic),
    props: Dynamic,
  )
  Fragment(children: List(Element))
  Debug(id: String, meta: Option(Dynamic), element: Element)
  Keyed(key: String, element: Element)
  IgnoreUpdate(element: Element)
  Provider(key: String, value: Dynamic, element: Element)
  Text(text: String)
  Custom(kind: String, data: String)
}

Constructors

Element(
  tag: String,
  attrs: List(Attribute),
  children: List(Element),
)

Component(
  component: FunctionalComponent(Dynamic),
  props: Dynamic,
)

```
Fragment(children: List(Element))
```

Debug(id: String, meta: Option(Dynamic), element: Element)

```
Keyed(key: String, element: Element)
```
```
IgnoreUpdate(element: Element)
```

Provider(key: String, value: Dynamic, element: Element)

```
Text(text: String)
```
```
Custom(kind: String, data: String)
```

FunctionalComponent

</>

pub type FunctionalComponent(p) =
  fn(Context, p) -> #(Context, Element)

HandlerFn

</>

pub type HandlerFn =
  fn(Dynamic) -> Nil

Hook

</>

pub type Hook {
  Callback(
    id: Unique,
    callback: fn() -> Nil,
    prev: Option(CallbackResult),
  )
  Memo(id: Unique, value: Dynamic, prev: Option(MemoResult))
  Effect(
    id: Unique,
    effect: fn() -> EffectCleanup,
    deps: HookDependencies,
    prev: Option(EffectResult),
  )
  Handler(id: Unique, handler_fn: HandlerFn)
  Reducer(id: Unique, reducer: Dynamic, cleanup: fn() -> Nil)
  State(id: Unique, value: Dynamic)
  Client(
    id: Unique,
    name: String,
    handle_event: Option(ClientEventHandler),
  )
}

Constructors

Callback(
  id: Unique,
  callback: fn() -> Nil,
  prev: Option(CallbackResult),
)

Memo(id: Unique, value: Dynamic, prev: Option(MemoResult))

Effect(
  id: Unique,
  effect: fn() -> EffectCleanup,
  deps: HookDependencies,
  prev: Option(EffectResult),
)

Handler(id: Unique, handler_fn: HandlerFn)

Reducer(id: Unique, reducer: Dynamic, cleanup: fn() -> Nil)

```
State(id: Unique, value: Dynamic)
```

Client(
  id: Unique,
  name: String,
  handle_event: Option(ClientEventHandler),
)

HookDependencies

</>

pub type HookDependencies =
  List(Dynamic)

IdentifiableHandler

</>

pub type IdentifiableHandler {
  IdentifiableHandler(id: Unique, handler: HandlerFn)
}

Constructors

IdentifiableHandler(id: Unique, handler: HandlerFn)

MemoResult

</>

pub type MemoResult {
  MemoResult(deps: Option(HookDependencies))
}

Constructors

MemoResult(deps: Option(HookDependencies))

Updater

</>

pub type Updater(r) {
  Updater(send: fn(r) -> Result(Nil, Nil))
}

Constructors

Updater(send: fn(r) -> Result(Nil, Nil))

Functions

compare_deps

</>

pub fn compare_deps(
  prev_deps: List(Dynamic),
  deps: List(Dynamic),
) -> Compared(List(Dynamic))

dep

</>

pub fn dep(dependency: a) -> Dynamic

dispatch_event

</>

pub fn dispatch_event(
  ctx: Context,
  id: Unique,
  name: String,
  payload: Option(String),
) -> Result(Nil, Nil)

fetch_or_init_hook

</>

pub fn fetch_or_init_hook(
  ctx: Context,
  init: fn() -> Hook,
) -> #(Context, Hook, Int)

get_event_handler

</>

pub fn get_event_handler(
  ctx: Context,
  id: Unique,
) -> #(Context, Result(IdentifiableHandler, Nil))

new

</>

pub fn new(
  view: Element,
  cuid_channel: Subject(Message),
  dispatcher: Option(Dispatcher),
  render_update: fn() -> Nil,
  update_hook: fn(Unique, fn(Hook) -> Hook) -> Nil,
) -> Context

prepare_for_reconciliation

</>

pub fn prepare_for_reconciliation(ctx: Context) -> Context

provider

</>

pub fn provider(
  key: String,
  value: a,
  element: Element,
) -> Element

push_event_handler

</>

pub fn push_event_handler(
  ctx: Context,
  identifiable_cb: IdentifiableHandler,
) -> #(Context, Unique)

update_hook

</>

pub fn update_hook(
  ctx: Context,
  hook: Hook,
  index: Int,
) -> Context