Hybrids

Extraordinary JavaScript UI framework with unique declarative and functiona...

Web ComponentsUI Framework
hybridsjs/hybridshybrids.js.orghybrids

README


npm version build status coverage status

hybrids is a JavaScript UI framework for creating fully-featured web applications, components libraries, or single web components with unique mixed declarative and functional architecture.

The main goal of the framework is to provide a complete set of tools for the web platform - everything without external dependencies. It supports building UI components, managing complex states, creating app flows with client-side routing, and localizing its content for the worldwide markets. All of the parts follow the same unique concepts making it easy to understand and use!

Quick Look


The Simplest Structure


The component model is based on plain objects and pure functions*, still using the Web Components API under the hood:

  1. ``` js
  2. import { html, define } from "hybrids";
  3.   
  4. function increaseCount(host) {
  5.   host.count += 1;
  6. }

  8. export default define({
  9.   tag: "simple-counter",
  10.   count: 0,
  11.   render: ({ count }) => html`
  12.     <button onclick="${increaseCount}">
  13.       Count: ${count}
  14.     </button>
  15.   `,
  16. });
  17. ```

  1. ``` html
  2. <simple-counter count="42"></simple-counter>
  3. ```
[![Edit web component built with hybrids library](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/simple-counter-web-component-built-with-hybrids-library-co2ow?file=/src/SimpleCounter.js)

\* Pure functions only apply to the component definition. Side effects attached to event listeners might mutate the host element.

You can read more in the Component Model section of the documentation.

Seamless Localization


Built-in support for automatic translation of the component's content makes translation seamless and easy to integrate. Additionally, the framework provides a way to add dynamic messages with plural forms, HTML content, or use messages outside of the template context. Also, it comes with handy CLI tool to extract messages from the source code!

  1. ``` js
  2. import { define, html, localize } from "hybrids";

  4. export default define({
  5.   tag: "my-element",
  6.   name: "",
  7.   render: ({ name }) => html`
  8.     <div>Hello ${name}!</div>
  9.   `,
  10. });

  12. localize("pl", {
  13.   "Hello ${0}!": {
  14.     message: "Witaj ${0}!",
  15.   },
  16. });
  17. ```

You can read more in the Localization section of the documentation.

Complex State Management


The store module provides a global state management based on declarative model definitions with built-in support for async external storages, relations, offline caching, and many more. It follows the declarative architecture to simplify the process of defining and using data structures:

  1. ``` js
  2. import { define, store, html } from "hybrids";

  4. const User = {
  5.   id: true,
  6.   firstName: "",
  7.   lastName: "",
  8.   [store.connect] : {
  9.     get: id => fetch(`/users/${id}`).then(res => res.json()),
  10.   },
  11. };

  13. define({
  14.   tag: "my-user-details",
  15.   user: store(User),
  16.   render: ({ user }) => html`
  17.     <div>
  18.       ${store.pending(user) && `Loading...`}
  19.       ${store.error(user) && `Something went wrong...`}

  21.       ${store.ready(user) && html`
  22.         <p>${user.firstName} ${user.lastName}</p>
  23.       `}
  24.     </div>
  25.   `,
  26. });
  27. ```

  1. ``` html
  2. <my-user-details user="2"></my-user-details>
  3. ```

You can read more in the Store section of the documentation.

Structural Client-Side Routing


The router module provides a global navigation system for client-side applications. Rather than just matching URLs with the corresponding components, it depends on a tree-like structure of views, which have their own routing configuration in the component definition. It makes the URLs optional, have out-the-box support for dialogs, protected views, and many more.

  1. ``` js
  2. import { define, html, router } from "hybrids";

  4. import Home from "./views/Home.js";

  6. export define({
  7.   tag: "my-app",
  8.   views: router(Home),
  9.   content: ({ views }) => html`
  10.     <my-app-layout>
  11.       ${views}
  12.     </my-app-layout>
  13.   `,
  14. });
  15. ```

  1. ``` html
  2. <my-app></my-app>
  3. ```

You can read more in the Router section of the documentation.

Documentation


The project documentation is available at the hybrids.js.org site.

Community


Follow on Twitter
Chat on Gitter

License


hybrids is released under the MIT License.