Extensible Go library for creating fast, SSR-first frontend avoiding vanilla templating downsides.
Creating asynchronous and dynamic layout parts is a complex problem for larger projects using `html/template`.
Library tries to simplify this process.
Let's go straight into a simple example.
Then, we will dig into details, step by step, how it works.
Kyoto provides a simple net/http handlers and function wrappers
to handle pages rendering and serving.
See functions inside of nethttp.go file for details and advanced usage.
Kyoto provides a way to define components.
It's a very common approach for modern libraries to manage frontend parts.
In kyoto each component is a context receiver, which returns it's state.
Each component becomes a part of the page or top-level component,
which executes component asynchronously and gets a state future object.
In that way your components are executing in a non-blocking way.
Pages are just top-level components, where you can configure rendering and page related stuff.
As an option, you can wrap component with another function to accept additional paramenters from top-level page/component.
Kyoto provides a context,
which holds common objects like http.ResponseWriter, *http.Request, etc.
See kyoto.Context for details.
Kyoto provides a set of parameters and functions
to provide a comfortable template building process.
You can configure template building parameters with
See template.go for available functions
and kyoto.TemplateConfiguration for configuration details.
Kyoto provides a way to simplify building dynamic UIs.
For this purpose it has a feature named actions.
Logic is pretty simple.
Client calls an action (sends a request to the server).
Action is executing on server side and
server is sending updated component markup to the client
which will be morphed into DOM.
To use actions, you need to go through a few steps.
You'll need to include a client into page (JS functions for communication)
and register an actions handler for a needed component.
Let's start from including a client.
Then, let's register an actions handler for a needed component.
Now we ready to use actions to provide a dynamic UI.
In this example you can see provided modifications to the quick start example.
First, we've added a state and name into our components' markup.
In this way we are saving our components' state between actions and find a component root.
Unfortunately, we have to manually provide a component name for now,
we haven't found a way to provide it dynamically.
Second, we've added a reload button with onclick function call.
We're using a function Action provided by a client.
Action triggering will be described in details later.
Third, we've added an action handler inside of our component.
This handler will be executed when a client calls an action with a corresponding name.
It's highly recommended to keep components' state as small as possible.
It will be transmitted on each action call.
Kyoto have multiple ways to trigger actions.
Now we will check them one by one.
This is the simplest way to trigger an action.
It's just a function call with a referer (usually 'this', f.e. button) as a first argument (used to determine root),
action name as a second argument and arguments as a rest.
Arguments must to be JSON serializable.
It's possible to trigger an action of another component.
If you want to call an action of parent component, use $ prefix in action name.
If you want to call an action of component by id, use <id:action> as an action name.
This is a specific action which is triggered when a form is submitted.
Usually called in onsubmit="..." attribute of a form.
You'll need to implement 'Submit' action to handle this trigger.
This is a special HTML attribute which will trigger an action on page load.
This may be useful for components' lazy loading.
With this special HTML attributes you can trigger an action with interval.
Useful for components that must to be updated over time (f.e. charts, stats, etc).
You can use this trigger with ssa:poll and ssa:poll.interval HTML attributes.
This one attribute allows you to trigger an action when an element is visible on the screen.
May be useful for lazy loading.
Kyoto provides a way to control action flow.
For now, it's possible to control display style on component call
and push multiple UI updates to the client during a single action.
Because kyoto makes a roundtrip to the server every time an action is triggered on the page,
there are cases where the page may not react immediately to a user event (like a click).
That's why the library provides a way to easily control display attributes on action call.
You can use this HTML attribute to control display during action call.
At the end of an action the layout will be restored.
A small note. Don't forget to set a default display for loading elements like spinners and loaders.
You can push multiple component UI updates during a single action call.
Just call kyoto.ActionFlush(ctx, state) to initiate an update.
Kyoto provides a way to control action rendering.
Now there is at least 2 rendering options after an action call: morph (default) and replace.
Morph will try to morph received markup to the current one with morphdom library.
In case of an error, or explicit "replace" mode, markup will be replaced with x.outerHTML = '...'.