Kino.Table behaviour (Kino v0.19.0)

@type column() :: %{
  :key => term(),
  :label => String.t(),
  optional(:type) => type(),
  optional(:summary) => %{required(String.t()) => String.t()}
}

info()

@type info() :: %{
  :name => String.t(),
  :features => [:export | :refetch | :pagination | :sorting | :relocate],
  optional(:export) => %{formats: [String.t()]},
  optional(:num_rows) => pos_integer()
}

rows_spec()

@type rows_spec() :: %{
  offset: non_neg_integer(),
  limit: pos_integer(),
  order: nil | %{direction: :asc | :desc, key: term()},
  relocates: [%{from_index: non_neg_integer(), to_index: non_neg_integer()}]
}

state()

@type state() :: term()

t()

@type t() :: Kino.JS.Live.t()

type()

@type type() :: String.t()

The following types have meaning on the front-end:

"date"
"list"
"number"
"struct"
"text"
"uri"

Callbacks

export_data(rows_spec, state, t)

(optional)

@callback export_data(rows_spec(), state(), String.t()) ::
  {:ok, %{data: binary(), extension: String.t(), type: String.t()}}

Exports the data for download.

The returned map must contain the binary, the file extension and the mime type.

get_data(rows_spec, state)

@callback get_data(rows_spec(), state()) ::
  {:ok,
   %{
     columns: [column()],
     data: {:columns | :rows, [[String.t()]]},
     total_rows: non_neg_integer() | nil
   }, state()}

Loads data matching the given specification.

init(init_arg)

@callback init(init_arg :: term()) :: {:ok, info(), state()}

Invoked once to initialize server state.

on_update(update_arg, state)

(optional)

@callback on_update(update_arg :: term(), state :: state()) :: {:ok, state()}

Invoked to update state with new data.

This callback is called in response to update/2.

Functions

new(module, init_arg, opts \\ [])

@spec new(module(), term(), keyword()) :: t()

Creates a new tabular kino using the given module as data specification.

Options

:export - a function called to export the given kino to Markdown. This works the same as Kino.JS.new/3, except the function receives the state as an argument

update(kino, update_arg)

@spec update(t(), term()) :: :ok

Updates the table with new data.

An arbitrary update event can be used and it is then handled by the on_update/2 callback.