Props is the Atomico recommended way to declare visible and accessible states at the instance level of your webcomponents, with props you can:

1. Access state via instance, example: document.querySelector("my-component").myStateProp.

2. Dispatch events on prop value change, example: document.querySelector("my-component").addEventListener("myPropChange",console.log).

3. Reflect attributes as prop, example: <my-component my-prop="...."> to document.querySelector("my-component").myProp.

4. define strict input types for props.

Syntax

Any function that represents the webcomponent will be able to associate the static object props for the declaration of reactive properties and attributes, for example:

Consider that:

1. The prop names in Camel Case format will be translated to for use as an attribute to the Kebab Case format, this behavior can be modified through the "attr" property when using a structured declaration.

2. Structured declarations require the "type" property minimally.

3. Not all types can use the "reflect" properties.

4. The declaration of the "value" property can vary depending on the type.

Simple statements

Simple statements allow setting just type validations.

Structured declaration

Improve the definition by adding utility declarations, allowing for example to reflect the property's value as attributes, automatically emit events or associate default values. Remember these types of declarations minimally require the use of the type property.

Prop.type

Prop.reflect

If the "reflect" property is set to true, its value is reflected as an attribute of the webcomponent, this is useful for the declaration of CSS states, example:

Prop.event

It allows dispatching an automatic event before the prop value change, example:

Where:

• event.type: String - optional, name of the event to be emitted when the prop is changed

• event.bubbles: Boolean - optional, indicates that the event can be listened to by containers.

• event.detail: Any - optional, allows to attach a custom detail for the event

The special properties of the event are the well-known Event Init, you can know more details in the .

Prop.value

Atomico allows the definition of default values of the props.

The association of callback as value allows generating unique values for each instance of the webcomponent, this is useful with the Object and Array types since it eliminates the references between instances.

Reactivity in the scope of the webcomponent

Atomico removes the use of "this" given its functional approach, but adds the hook [useProp] (hooks / useprop.md) which allows to reference a prop for use with a functional syntax, eg:

Recommended articles

Cycle as attribute:

the given value is transformed to the corresponding type, be it String, Number, Boolean, Array or Object, once transformed it is sent to the cycle as property.

Cycle as property:

evaluates if the value is of the declared type:

• If it corresponds to the type:

  1. It is saved in props.

  2. An event is emitted (if this has been configured in the prop).

  3. It is reflected as an attribute (if this has been configured in the prop).

Syntax

Where:

• dispatchEvent: callback, dispatches the event from the webcomponent and allows defining the detail by receiving a first parameter

• myEvent: string, name of the event to dispatch.

• eventInit: optional object, event configuration.

Examples

Event customization

The second parameter of useEvent allows customizing the behavior of the even:

Recommended articles

Syntax

useEffect(effectCallback, optionalArgumentList);

Where :

1. effectCallback : Function that is executed one or more times according to optionalArgumentList,effectCallback can return a function that will be executed only if effectCallback is executed again or the webcomponent is unmounted.

2. optionalArgumentList: Array of arguments that controls the execution of effectCallback, if an argument ofoptionalArgumentList changes it will trigger that effectCallback is executed again without first cleaning the effects subscribed by the previous execution.

Example

useLayoutEffect

useLayoutEffect replicates the logic of useEffect but with synchronous execution after rendering.

useInsertionEffect

useLayoutEffect replicates the logic of useEffect but with synchronous execution before rendering.

The "atomico/test-hooks" submodule is a direct part of Atomico's core and will allow you to run the customHook in a controlled way without the need for webcomponents.

createHooks

function that creates an isolated context that is shared globally with Atomico hooks when executing the load method

Instance

Where:

• optionalRender: Callback that allows restarting the hook's life cycle, this callback will be executed every time a hook like or requests the scope update, Atomico uses it to render the webcomponent again.

• opcionalHost: allows to share an object for the hook , Atomico uses it to share the instance of the webcomponent.

Return of the instance

Where:

• load: Function that allows to load the hooks to the temporary global context of Atomico.

• clearEffect: Function that activates the collector of useLayoutEffect, when executing clear Effect a callback will be returned that allows ending the collector for useEffect, closing the cycle of secondary effects.

  If clear Effect receives true as parameter, it communicates the unmounted.

Example:

./use-counter.js: customHook to test.

./use-counter.test.js: The example is based on the test environment from .

When to use the shadow Dom?

By creating a UI solution that coexists in the web ecosystem such as HTML, libraries and frameworks, since the shadowDOM allows you to:

1. Protect your UI from libraries like React, Vue and others

2. Associate styles natively, efficiently and safely

3. Reference lightDOM content in the shadowDOM

Webcomponents with Shadow DOM are ideal for creating cross UI solutions as they coexist without conflict with the entire web ecosystem.

Why use shadowDOM?

To protect our component at the DOM manipulation level and take advantage of some of the benefits of the shadowDOM such as:

1. Slot management

2. CSS appearance of web component.

3. The shadowDOM is ideal for creating components that interact with libraries like React, Vue or others. The ShadowDOM protects the DOM it contains from manipulations generated by other libraries.

Slot management

Slots allow us to reflect existing nodes in the lightDOM into the shadowDOM, example:

This is really useful, since we can group slots according to their name in a specific place of the webcomponent.

We invite you to learn more about slots through the following guide:

CSS appearance of web component.

The shadowDOM allows you to do something fantastic, protect your CSS from global styles, this has 2 great advantages:

1. The appearance of our component will not be affected by global CSS declarations.

2. Customization protected by CSS custom Properties

We invite you to learn more about handling styles in atomic through the following guide:

Atomico makes it easy to declare events at the type level using the Host type.

Example

In the previous code, we have declared the onMyCustomEvent event at the type level. According to the template logic, this event will be dispatched every time the button is clicked, and the detail attached to this event will be of type CustomDetail.

Meta-types allow you to define properties not covered by Atomico's Automatic support, such as:

1. Type declaration

2. Event declaration

3. Method declaration

import { Component } from "atomico";

// 📌 Parameters for the function and set 
//    the structure rules for myComponent.props
interface Props{
    checked: boolean;
    value: string
}

// 📌 Optional, improves the typing experience 
//    in JSX (Atomico, Preact and React)
interface MetaProps {
    myMethod:(value: number)=>void;
    onMyEvent: Event;
}

const myComponent: Component<Props, MetaProps> = (props) => {
    const myMethod = (value: number)=>{};
    return <host myMethod={myMethod }></host>
}

myComponent.props = {
    checked: Boolean,
    value: { type: String, event: {type: "MyEvent"} },
}

The declaration const myComponent: Component<Props, MetaProps> defines at the Typescript level the types of props and other options with which the component should be structured.

This process is strict but makes autocompletion and error detection easier in the component declaration.

Some warnings that this type can create are:

1. The declaration of the prop in myComponents.props does not match the type declared in Props.

2. A props declaration is missing.

3. Props has invalid metadata, example reflect has been defined for a Promise type.

Although the props today offer strict rules, Type allows them to be complemented with a direct definition of the types to accept, example:

import { Props } from "atomico";

function component(){
    return <host/>
}

component.props = {
    value: String as Type<"A"|"B"|"C">
}

The above is equivalent to using value as a function, example:

import { Props } from "atomico";

function component(){
    return <host/>
}

component.props = {
    value: {
        type: String,
        value: ():"A"|"B"|"C"=>"A"
    }
}

This is also valid for the null type that in Atomic translates as Any, example:

component.props = {
    src: null as Type<string | Promise<any>>
}

The Props type allows you to infer the types of props already declared in the props object, example:

import { Props } from "atomico";

function myComponent(props: Props<typeof myComponent>) { // {checked: boolean}
    return <host>Hello {props.checked?"Yes":"No"}</host>
}

myComponent.props = {
    checked: Boolean,
}

The main difference with the Component type is that Props does not generate stricture rules for the component, it only infers the props object to be used as an argument.

At the Typescript Props level, it does evaluate the structure of the component, in order to correctly infer the props, so if the component has a writing error, a warning about this type will be displayed.

With Atomico and Typescript you will be able to:

1. Construct the props parameter of your functional component.

2. Check the correct declaration of your component.

3. Check the correct use of hooks.

📌 If you are a Typescript user I recommend using TSX vs the template-string, as you will benefit from:

1. JSX runtime, Typescript will automatically import Atomico upon detecting the use of TSX.

2. Autocompletion and validation of attributes, properties and events of tags and webcomponents.

3. Webcomponent instance validation using constructors.

Construct the props parameter of your functional component.

Your component as a function does not infer the props, to help infer the props you should use the Props type, example:

From an object: Construct props directly from the declaring object.

From the component: Build the props from the component, internally Atomico captures the property component.props.

From another customElement component: It's unusal, but when you extend another component you can infer the props from its constructor.

Check the correct declaration of your component.

Typescript checks the structure of your component by using the c function on it, thus validating which props and styles have been attached.

The return of c is a CustomElement with the types of the associated props, example:

It will report an error to Typescript since this component's props define that value is of type number, this validation also applies when instantiating your CustromElement in JSX or TSX.

Both TSX or JSX will help you to build better applications since it verifies the types according to the definition of its component, this verification is Free, it does not need plugins, only a tsconfig.json file and Typescript to automate the revision.

Atomico supports through the use of the Host type, the declaration of events and methods, this is useful for associating meta-types to the customElement instance when using JSX or TSX.

Host to declare events

Host will be useful for you to declare your event using JSX or TSX regardless of its origin, example:

import { Host, c, useEvent } from "atomico";

function myComponent(): Host<{
  onMyCustomEvent: Event
}> {
  const dispatch = useEvent("MyCustomEvent");
  return <host>
      <button onclick={dispatch}>click</button>
  </host>;
}

export const MyComponent = c(myComponent);

The use of Host allows that when using JSX or TSX your event is validated through Typescript, this also applies when using @atomico/react, example:

import { MyComponent } from "my-componnet";

<MyComponent
  onMyCustomEvent={(event) => {
    event.currentTarget; //  < MyComponent
  }}
></MyComponent>;

Note event.currentTarget accesses the CustomElement, example properties and more.

That has another benefit, capturing the event as a type to be used in an external handler, example:

If you are a React user, it is common for you to make component declarations like these:

Thanks to the previous code in React we can:

1. Instantiate your component through its function, example <MyComponent>

2. Friendly export component as module

In Atomico there are some small differences 👇

we recommend in Atomico

Export the return of the c function, since it is instantiable at the JSX level or when using the new operator, example:

Gracias a lo anterior podemos:

1. Instantiate your component with TS-level type validation either by using JSX or the new operator with, but remember that to get this type of instances you must first have registered your customElement in the same file or another.

2. Export the useful component to instantiate.

Atomico escapes React DOM immutability logic and moves closer to the native DOM API, this means that Atomico at the scope level is only responsible for receiving the props and rendering the DOM, but it does not observe the internal mutations of the DOM automatically, this is because the native level mutations can come from anywhere, for example other libraries. Now for ensure state synchronization it is convenient that every webcomponent that wants to be observed has the obligation to dispatch a change event

You can easily achieve this by using useEvent or Prop.event, applying that you can:

capture change as event

const [ value, setValue ] = useState("init"); // you can also use useProp

<host>
    <my-component 
        value={value} 
        onchange={({target})=>setValue(target.value)}
    ></my-component>
</host>

Force a fixed value

const update = useUpdate();

<host>
    <my-component 
        value={value} 
        onchange={update}></my-component>
</host>

the update function forces an update on the component, in order to redefine value according to the scope

How to render a webcomponent in Storybook with React

The following error is the most common when using Atomico in Storybook with React.

localhost/:1 Uncaught DOMException: Failed to execute 'define' on 'CustomElementRegistry': this constructor has already been used with this registry

We recommend using @atomico/react, this package creates a friendly wrapper for React.

Node

Atomico and automatic SSR support, you will not need additional packages, example:

// If your version of node accepts top-level await just point to 'atomico/ssr'
import 'atomico/ssr/load'; 
import { html } from 'atomico';
import { Component } from './static/component.js';
import express from 'express';

const app 

Unlike other libraries, Atomico automatically hydrates when mounting the component in the DOM, so no additional client configuration is required.

SSR/SSG via @atomico/react

The @atomico/react package allows you to take advantage of support for SSR or SSG designed for React/Preact, example:

1. Next.js:

   • Example:

   • Repo:

Astro build

allows to integrate SSR and SSG support to Astro build, We have used this integration to create the site.

Classes external to Atomico

component: function that declares the webcomponent for Atomico.

VanillaElement: class that will be extended by Atomico to create Component, Atomico will not break the life cycle of the component, allowing them to interact freely.

Classes internal to Atomico

classes produced by the Atomico function c, these can be extended between components, example:

Consider the following effects when using this inheritance model:

1. The render will be rewritten.

2. The props are inherited, Atomico will reuse the previously declared props.

3. Styles are inherited. Atomico will merge the stylesheets.

Inheritance outside of Atomico

The c function creates an optimized standard custom element, which can be extended to modify its behavior, be:

1. Adding methods.

2. Creating or replacing style sheets.

3. Creando nuevas propiedades.

Suppose we have a MyButton product of the function c, we can extend this component to modify its appearance without the need to completely rewrite it, example:

The benefit of this inheritance is to simplify the modification of the appearance of a component created with Atomico, since it avoids its rewriting.

Now, Atomico includes a context API as part of its core. We recommend implementing it as an alternative to using useChannel.

An alternative to React's context but solely based on hooks.

Modulo

import { useChannel } from "@atomico/hooks/use-channel";

Syntax

Where :

1. channel: String, defines the name of the event to be used to generate the channel.

2. parentValue: Value inherited by the parent component.

3. setChildValue: Callback

Example

This hook is used by

Many teams decide to use Atomico for the development of their design systems thanks to its similarity with React, which greatly facilitates the incorporation of human talent into the development of design systems.

Why use Atomico to create design systems?

1. Atomico offers you Storybook 7 Support with superpowers, thanks to @atomico/storybook you can create stories without the need to declare the argTypes or args since creates them for you

2. makes it easy for you to build in NPM-friendly ESM format

3. makes it easy for you to export your code by automatically adding the metadata so that it is optimally consumed as a package, @atomico/exports can even automatically create wrappers for React, Preact and Vue

4. makes it easy for you to maintain a token system efficiently and sustainably

Use cases

IBM IX

We thank IBM IX since they have shared their experience in the development of the design system for their client Barmer, you can follow this case through Discord or Github.

First let's say that Atomico is light since it has a size close to 3kB vs React + ReactDOM that have a size close to 60kB, now if your project is already written in React I can integrate Atomico progressively since a component created can be instantiated as a component for React thanks to @atomico/react, example:

Magical 🪄, isn't it?... well now let's speed up your Atomico learning path:

How to declare a component?

Atomico, like React, allows a declaration of components using only functions, example:

From the example we will highlight the following differences:

1. In Atomico you only use one import.

2. useProp is like useState, but with the difference that useProp references the state from the webcomponent property defined in counter.props.

3. const props allows us to create the properties of our webcomponent, these are like React's propTypes, but with a big difference they are associated with the instance and can be read and modified by referencing the node, example

Now I want to invite you to learn how to declare a style using Atomico.

How do you declare styles using Atomico?

It is common to see the use of libraries such as Emotion or styled-components to encapsulate styles in React, but these add an additional cost, be it for performance or bundle, in Atomico there is no such cost.

Instances, children and slots

It is normal for React to create components that you then instantiate within other components, for example:

with Atomico there are certain differences:

1. With Atomico you can instantiate CustomElements using its constructor

The constructor in Atomic is the product of the c function and is the one you will use to register your webcomponent, example:

According to the previous example, you can instantiate MyComponent as a JSX Component, example:

This instance type allows autocompletion at the JSX level and type validation at the Typescript level.

2. With Atomico you can instantiate components as functions as long as these are only stateless functions

This will be useful for reusing templates, but always remember stateless.

We invite you to discover part of the development experience you will get with Atomico:

Create really fast webcomponents

Quick components to write since with Atomico you will require fewer lines of code to declare your webcomponents which will help you to be more productive

Fast in performance, since Atomico sends less code to the client, making your interface load quickly

Create web components with less code

This is thanks to a functional orientation inherited from React hooks plus some internal optimization from Atomic that ease the process of shaking the tree at compile time, achieving in this way sending the client a highly optimized JS that only has what you really use

Create webcomponents with a functional orientation

This is thanks to Atomico's reliance on React hooks syntax plus the ability to completely eliminate the need for this when using webcomponents.

Create friendly webcomponents for React, Vue and other libraries

Atomic offers additional coverage for native behavior for React and Vue, allowing your component to be more embed-friendly, example React:

Thanks for being here and getting started with Atomico. Let's talk a little about what Atomico offers today:

1. Development agility, Atomico's functional approach simplifies code at all stages of development.

2. Lightweight inside and out, Atomico allows you to create a component with less code and with a low dependency impact. Approximately 3kb.

3. Really fast, Atomico has a in the browser and an agile development experience. Let's understand what a webcomponent created with Atomico looks like:

Let's analyze the code in parts ...

1.0 Imports

What have we imported?

1. c: Function that transforms the functional component into a standard customElement.

2. css: Function that allows creating the CSSStyleSheet (CSS) for our component as long as it declares the shadowDom.

2.0 Creating Our Web Component: Custom Element Definition

2.1 Defining Component Render Function

Our function receives all the props (Properties and Attributes) declared in props, the component function declares all the logic and template of the webcomponent. An important rule within Atomico is "📌 every component created with Atomico must always return the tag".

2.2 Defining Component Properties(props) and Attributes

Atomico detects the prop (Properties and Attributes) of the component thanks to the association of the props object, this through the use of index and value allows you to define:

1. index: Name of the property and attribute.

2. value: type of the prop.

From the example we can infer that Atomico will create in our webcomponent a property and attribute called message and this can only receive values of the String type.

2.3 Defining Encapsulated Styles for the Component

Atomico detects the static styles of your component thanks to the association of the styles property:

styles accepts individual or list CSSStyleSheet (CSS) values, the return from the css function is a standard CSSStyleSheet, so it can be shared outside of Atomico.

Web Component Registration and Definition

To create our standard customElement we will have to deliver our functional component to the c function of the Atomico module, the c function will generate as a return a customElement that can be defined or extended.

Example

import { c } from "atomico"; // 2.5kB

const MyComponent = c(
  ({name})=><host shadowDom>Hello, {name}</host>,
  {
    props: { name: String }

import { c } from "atomico"; // 2.5kB

const MyComponent = c(
  ({name})=><host shadowDom>Hello, {name}</host>,
  {
    props: { name: String }

Atomico simplifies learning, workflow and maintenance when creating webcomponents and achieves it with:

1. Scalable and reusable interfaces: with Atomico the code is simpler and you can apply practices that facilitate the reuse of your code.

2. Open communication: with Atomico you can communicate states by events, properties or methods.

3. Agnostic: your custom Element will work in any web-compatible library, eg React, Vue, Svelte or Angular.

4. Performance: Atomico has a comparative performance at Svelte levels, winning the third position in performance according to in a comparison of 55 libraries among which is React, Vue, Stencil and Lit.

API

Syntax

const refHost = useHost();

Returns the instance of the webcomponent in reference format, this reference allows to extend behaviors when creating customHooks.

Example

import { useHost, useEffect } from "atomico";

function useListener(type: string, callback: (ev: Event) => void) {
  const ref = useHost();
  useEffect(() => {
    const { current } = ref;
    current.addEventListener(type, callback);
    return () => current.removeEventListener(type, callback);
  }, []);
}

From the example we can highlight that useListener is a customHook that allows listening to an event from the webcomponent without the need to link said event to the VirtualDOM.

Syntax

const ref = useRef(optionalCurrent);

Example

import { useRef, useEffect, useState } from "atomico";

function component() {
  const ref = useRef();
  const [message, setMessage] = useState();
  useEffect(() => {
    const { current } = ref;
    current.addEventListener("input", () => {
      if (current.validity.typeMismatch) {
        setMessage("Invalid!");
      }
      current.setCustomValidity("");
    });
  }, []);
  return (
    <host>
      <input type="email" ref={ref} />
      {message && <h1>{message}</h1>}
    </host>
  );
}

Observation

The reference object is useful for referencing nodes between customHooks.

This hook enables you to take control of the context from the component that instantiates useProvider, thus avoiding the need to instantiate the context node in the DOM.

Example of the useProvider hook:

import { createContext, useProvider, c } from "atomico";

export const Theme = createContext({
    color: "white",
    background: "black"
});

export const App = c(()=>{
    useProvider(Theme,{
        color: "red",
        background: "yellow"
    });
    
    return <host shadowDom><slot/></host>
});

Objective

Avoid creating an instantiable context node in the DOM.

It is normal that the state of your component depends on the references of a slot, this hook facilitates the process of observing these references without the need to associate the changes to a state.

Syntax

const update = useUpdate();

Where:

1. update: Callback, force component update.

Creating sites with Atomico is really easy and SEO friendly because:

1. With Atomico you can perform SSR and SSG thanks to tools like Astro build, with Astro + Atomico you can send previously rendered components to the client, thus giving a result at the HTML level that is really friendly with search engines.

2. Atomico being really small (3kB) your sites will load fast, especially if you only apply SSG with Atomico.

3. Atomico not only supports SSR through Astro, you can SSR today with Atomico in Next.js, Express or any environment that supports ESM modules.

4. (Coming soon) Yes, with Atomico soon you will be able to create blocks for Gutenberg easily

We recommend for SSR or SSG based sites

we recommend you for new projects

We recommend the use of build with the @atomico/astro plugin, with this you can create sites like

we recommend you for projects based on React

Preferably we recommend + React + Atomico, but in case your project inherits the use of Next.js you can do SSR with Atomico in Next.js using .

Special properties

render

By default, the render is configured to be used within the webcomponent by reading the return of the function, but it can be used outside of Atomico, example:

Constructor with custom element

This technique allows you to use any registered custom element without the need to know its tag-name for its use, example:

Advantage :

1. Remove leverage from tag-name

2. Infer the types of the props and autocomplete only if you use JSX and Atomico.

Constructor with DOM

Atomico allows the use of the DOM, for this it establishes its created or recovered node as a constructor, example:

Dynamic constructor

Atomico associates the variable associated with the instance as a constructor, example:

staticNode

allows to declare a node within the scope of the function as static, this will optimize the diff process between render, achieving better performance in cases of high stress of the UI, example:

the biggest advantage of this is that the node accesses the scope of the webcomponent

cloneNode

Allows to clone a node from the virtualDOM, example:

The objective of this feature is to retrieve slot and use it as a template from the webcomponent.

SSR hydration

Atomico allows reusing existing DOM in the document. This is done during the webcomponent instatiation, by setting a special property in the tag to mark it for hydration.

This can be done for shadowDom too:

useProp allows you to work with a prop(property) of the webcomponent in a similar way to useState.

Syntax

Where :

• value: Current value of the prop.

• setValue: Callback to update the value of the prop.

• myProp: string, defines the name of the prop to be used by the hook.

Example

Where:

1. useCounter is a customHook and that it can work with any property of the webcomponent of type Number.

2. useCounter returns 2 methods increment and decrement that modify the value of the prop.

3. useCounter can be instantiated multiple times for different properties.

Syntax

const memoValue = useMemo(callback, optionalArgumentList);

Where :

1. memoValue : Return memorized by useMemo.

2. callback: Function that is executed one or more times according to optionalArgumentList.

3. optionalArgumentList: Array of arguments that controls the execution of callback, if an argument of optionalArgumentList changes it will trigger that callback is executed again.

useCallback

Hook that allows you to memorize a callback so that it keeps its scope

Where:

1. memoCallback : Return memorized by useCallback.

Syntax

JSX

Atomico supports jsx-runtime, alternatively you can import the h function to declare manual of the JSX pragma, eg:

Return rule

An important rule of Atomico's virtualDOM is that every webcomponent must return the <host/> tag since it represents the state of the webcomponent's DOM, such as:

1. Enable the use of the shadowDOM by declaring the shadowDom property.

2. Association of events, attributes or properties.

3. Template of the webcomponent.

Template

Event Association

Atomico considers that a property must be associated as an event if it is of the function type and begins with the prefix 'on', eg:

Simple lists

Lists with keys

the key property can receive values of the type of any type that allows generating a reference to the node, eg:

Node references

A technique inherited from React, it allows obtaining the reference of the node to which the Ref object is associated through the ref property, example:

The references must be immutable objects, to create it there is the hook that creates a reference for each instance of the webcomponent.

shadowDom property

This property allows you to declare the use of the shadowDom, eg:

Method association

You can declare a method by declaring a function in the host tag without using the prefix on in its name, eg:

If when creating or updating the DOM it does not detect the use of the property, it will be associated as a method of this, thus allowing it to be accessed from the DOM, eg:

To access the DOM safely wait for the resolution of the updated property created by the .

Hooks only for webcomponents

Hooks homogolates of React

@atomico/hooks

Atomico today offers more Hooks external to the core, we invite you to visit with more than 50 hooks to enhance the use of webcomponents 😎

Syntax

const [state, setState] = useState(optionalInitialState);

Where:

1. const [state,setState] : Return of useState, the arguments allow reading and updating of the state associated with the hook instance.

   • state : Current state.

   • setState: Current status updater.

2. useState( optionalInitialState ): Function that associates the state to the webcomponent:

   • optionalInitialState: Optional parameter that defines the initial state associated to the hook instance, If optionalInitialState is a function it will be executed in order to obtain the initial state only at the moment of the hook instance for the first time.

Example

With the new contexts API you will be able to easily communicate components without the need to handle events, by default the communication is top down, but through it you can share anything as long as it is defined as an object.

Atomico's api is similar to React's Context api, let's explore the behavior of Atomico's context api:

createContext

create a custom Element as a context, this will serve to synchronize all the components nested within it, you must always remember to declare the tagname of this customElement, example

useContext

It allows to consume the return of createContext, let's go back to the previous example and suppose that we want to consume the customElement Theme created by createContext, the code for this would be the following:

In this way useContext captures the value of the parent component or reuses the value given by default to createContext.

Custom context values

By setting the value prop on the context, you can pass custom values down the sub-tree:

When to use the Context API?

It is ideal to always prioritize a conversation between parent and child through events or props api, but sometimes the depth of the DOM makes this process difficult, for this the context api has been introduced. To remove DOM depth limitations and ensure synchronization based on a unique identifier, some ideal cases to solve with the context api are:

1. Synchronize states or private methods between components.

2. Share a value or states inherited from the parent regardless of DOM depth.

We recommend the @web/test-runner tool, if your project was created with the command npm init @atomico the test environment will be preconfigured, you can see this pre-configuration at https://github.com/atomicojs/base/tree/2-started.

Advanced (Documentation in progress)

To scale the test environment you can complement with tools such as:

1. : allows you to automate interactions and evaluate interactions of your interface.

2. : Allows you to evaluate the appearance changes of your component or application between versions.

Atomico's virtualDOM is:

1. Close to standard DOM .

2. Additional coverage to webcomponents.

Components as constructors

Atomico does not support the use of functions to instantiate the component as we traditionally do in React, so that the component can be instantiated as a constructor it must be a webcomponent or a real Node.

Event Association

Like React in Atomico you need to use the prefix on to announce an event, but there is a difference Atomico does not manipulate the name of the event so onClick is different from onclick, the purpose of this difference is to support custom events.

Keyes

the key property in Atomicoo can be of type String, Number, Symbol or other immutable reference.

dangerouslySetInnerHTML

If you develop with React, you will know 80% Atomico ... now why use Atomico?:

1. Atomico will not limit your React learning curve, what you learned in Atomico is applicable in React, for example hooks and virtualDOM.

2. Atomico is 3kB in size which is 7% of React + React-dom.

3. Better component abstraction, for example the use of the ShadowDOM will avoid the need to use css-in-js like styles-components or emotion, reducing dependencies.

4. Agnostic Components, what you create with React only works within React, what you create with Atomico works on the web, so you can use your components within React, Vue, Svelte or Html.

5. Exclusive component for React, the CLI @ atomico / exports automatically generates a wrapper component of your webcomponent for React, improving backward compatibility with React.

The following examples show some differences between React and Atomico.

Counter example

From the example we will highlight the following differences:

1. In Atomico you only use one import.

2. useProp is like useState, but with the difference that useProp references the state from the webcomponent property defined in counter.props.

3. counter.props allows us to create the properties of our webcomponent, these are like React's propTypes, but with a big difference they are associated with the instance and can be read and modified by referencing the node, example

CustomHooks example

From the example we will highlight the following differences:

1. The hook api is the same.

2. the component in Atomico returns the `<host/> tag.

Supported hooks

In Atomico you will have the most useful React hooks such as:

1. useRef

2. useState

3. useReducer

4. useLayoutEffect

CSS-in-JS

It is common to see the use of libraries such as Emotion or styled-components to encapsulate styles in React, but these add an additional cost, be it for performance or bundle, in Atomico there is no such cost.

useId is a Atomico Hook for generating unique IDs that can be passed to accessibility attributes.

Syntax

Example

The purpose of this hook is to facilitate the consumption of promises.

Syntax

where:

• callback : asynchronous function.

Atomico's render cycle works like this:

First, when the component is instantiated, 3 promises will be created pending resolution:

1. componentInstance.mounted: resolved once the connectedCallback has been executed by the customElement.

2. componentInstance.updated

useAsync

with a similar approach to React's use hook, but with scope approach.

scope approach? yes, this hook seeks to resolve a promise from a callback return, this allows you to regenerate the promise according to the scope, example:

fixture

function that allows to keep the render on a single node for each execution of it, the container will be unmounted at the end of each execution of it.

This allows each fixture execution inside it to be related to the container used for the test, allowing you to fily test external DOM changes, example:

The use of slots improves the composition allowing to reflect the content exposed in the lightDOM of the component in the shadowDOM of this, example:

The idea is to create an instance of AbortController every time the hook's parameters change. Each parameter change will abort the previously generated controller, thus cancelling any subscribed promises.

Example

The significant advantage of using useAbortController is the automatic cancellation of asynchronous processes that depend on it when modifying the arguments provided to useAbortController (similar to useEffect).

Atomico allows the definition of methods from the host tag, this in order to share the scope with the methods (Functions) of the component, but this escapes the definition of types, to patch this we must use the Host type, this will allow us to validate the method from the JSX, TSX and the component instance.

Host to method declaration

React and webcomponents

, this will allow to use custom tag with association of events and more, example:

Advantages: The react team will take care of the coverage of this characteristic.

Disadvantages: (Optional) The maintainer of the component must declare the types of the custom tag.

Although the use of the custom tag is a way of instantiating the component, many times it does not define the import path at the time of its use, complicating the resolution of the component's origin, to avoid this we recommend the use of the Atomico wrapper for React

1. Its name cannot have the on prefix since, if it does, Atomico will recognize it as a property expecting to listen to the event.

2. It can only have one listener, limiting others from observing the event.

useState

useState infers the type according to its initial state, if you don't define that state you can define the type manually, example:

The above statement will define that:

1. message

Yes, but Atomico doesn't only depend on ESM, it also depends on the following api's that you will have to cover with Polyfill or some bundle tool.

1. ESM modules: -

2. CustomElements: -

3. ShadowRoot:

Atomico integrates very easily into React, either using or .

@atomico/exports

CLI that decorates the package.json according to the code to be exported in order to share your code optimally. By using the --wrappers flag the CLI will detect the export of webcomponents and automatically create a wrapper for React, Preact and Vue.

You can learn more about in the following guide:

Status

• Decorator, Atomico's decorator extends atomico's rendering capabilities to storybook.

• Monorepo,

Atomico has 3 great hooks to solve asynchronous tasks:

1. : Processes asynchronous tasks and shows the status and resolution of these

2. : Allows you to pause rendering until a promise is resolved