Simple, light-weight, and well tested, universal semantic HTML elements as React components for iOS, Android, web, and desktop apps!

We at Expo recommend using platform agnostic primitives like View, Image, and Text whenever possible but sometimes that's not easy. Some primitives like Tables, and Footers are native to web only and currently have no way of easily accessing. This package aims to solve that while still being an optimal UI package for iOS, and Android.

What you get

• Using @expo/html-elements will optimize your website for SEO and accessibility. Meaning your websites are indexed more accurately and your native apps better accommodate physically impaired users.
  • This package takes full advantage of react-native-web a11y rules whenever possible.
  • For example, the H1 component will render an <h1 /> on web, a UILabel on iOS, and a TextView on Android.
• Every component can accept styles from the StyleSheet API.
• TypeScript works for iOS, Android, and web, no more having to create monkey patches to use href on a Text element.
• This package is completely side-effect free!

Setup

Install:

yarn add @expo/html-elements

Import and use the package:

import { H1 } from '@expo/html-elements';

Components

Here is a list of all the currently supported elements and the web feature they map to. Not all HTML elements are supported. There are some HTML elements that mostly overlap with some universal modules, you should always try to use the universal modules whenever possible. All supported components are a capitalized variation of the semantic HTML they implement/emulate.

External

Other features not implemented in this package can be found in different parts of the Expo ecosystem.

Headings

Header elements will use the expected font size and margins from web universally. You can see how the native CSS units (rem, and em) are transformed in css/units.

import { H1, H2, H3, H4, H5, H6 } from '@expo/html-elements';

<H1/>

import { H1 } from '@expo/html-elements';
export default () => <H1>Example<H1/>

<H2/>

import { H2 } from '@expo/html-elements';
export default () => <H2>Example<H2/>

<H3/>

import { H3 } from '@expo/html-elements';
export default () => <H3>Example<H3/>

<H4/>

import { H4 } from '@expo/html-elements';
export default () => <H4>Example<H4/>

<H5/>

import { H5 } from '@expo/html-elements';
export default () => <H5>Example<H5/>

<H6/>

import { H6 } from '@expo/html-elements';
export default () => <H6>Example<H6/>

Link

<A/>

You can use the anchor element with href prop to open links. On native this will attempt to use the Linking API to open the href.

• The CSS style is fully normalized to match <Text />
• For pseudo-class effects like hover and focus states check out the package react-native-web-hooks | tutorial

import { A } from '@expo/html-elements';

export default () => <A href="#" target="_blank" />;
}

Layout

You can use layout elements like Header, Main, Footer, Section, Nav, etc. as a drop-in replacement for Views in your existing app.

Default Layout style

All layout HTML elements inherit the shared style of <View /> to accommodate the Yoga layout engine which we use on native for iOS, and Android.

• display is always flex. This is because Yoga only implements display: flex.
• flex-direction is always column instead of row.

Why use Layout elements

Consider the following: in your app you have a basic element at the top which wraps the buttons and title. A screen reader doesn't understand that this is a header, and mostly neither does a web crawler. But if you replace the encasing view with a <Header /> the following happens:

• iOS: UIView uses UIAccessibilityTraitHeader.
• Android: View will use the proper AccessibilityNodeInfoCompat.CollectionItemInfoCompat | docs.
• web: render an HTML 5 <header /> with the ARIA role set to "banner".

Some elements like Footer and Main have no iOS, or Android enhancements, but they'll still improve web. Using the proper HTML 5 elements will make your layout compliant with the HTML5 outline algorithm.

<Div/>

Renders a <div /> on web and a View with no ARIA set on mobile.

import { Div } from '@expo/html-elements';

export default () => (
    <Div>
      <P>Some content in the main element</P>
    </Div>
  );
)

<Nav/>

import { Nav } from '@expo/html-elements';

export default () => <Nav />;

<Header/>

Renders a <header /> on web with ARIA set to banner and a View with ARIA set to header on mobile.

import { Header } from '@expo/html-elements';

export default () => <Header />;

<Main/>

Renders a <main /> on web with ARIA role set to main and a View with no ARIA set on mobile.

import { Main } from '@expo/html-elements';

export default () => (
    <Main>
      <P>Some content in the main element</P>
    </Main>
  );
)

<Section/>

Renders a <section /> on web with ARIA set to region and a View with ARIA set to summary on mobile.

import { Section } from '@expo/html-elements';

export default () => <Section />;

<Article/>

Renders an <article /> on web and a View everywhere else.

import { Article } from '@expo/html-elements';

export default () => <Article />;

<Aside/>

import { Aside } from '@expo/html-elements';

export default () => <Aside />;

<Footer/>

Renders an <footer /> on web and a View everywhere else.

import { Footer } from '@expo/html-elements';

export default () => <Footer />;

Text

Text elements currently use Text universally rendering either a div or span to emulate Yoga style properly.

• Style is modified to match web.
• All font styles are reset (minus Code, and Pre).
• All elements accept styles from StyleSheet API.

import { P, B, S, I, BR, Code } from '@expo/html-elements';

export default () => (
  <>
    <P>
      Hello<B>World (in bold)</B>
    </P>
    <S>strike text</S>
    

    <I>Italic</I>
    <Code>const foo = true</Code>
  </>
);

<P/>

Standard paragraph element.

<B/>

Bold text text.

<Strong/>

Alternate bold text.

<Span/>

Inline text element.

<S/>

Strike through text.

<Del/>

Alternate strike through text.

<I/>

Italic text.

<EM/>

Alternate italic text.

<Code/>

Inline code block with fontFamily: 'Courier' on iOS and Web, fontFamily: 'monospace' on Android.

<Pre/>

Render a preformatted code block with fontFamily: 'Courier' on iOS and Web, fontFamily: 'monospace' on Android.

<Pre>{`
body {
  color: red;
}
`}</Pre>

// Or pass views

<Pre>
  <Code>{`const val = true`}</Code>
</Pre>

<Mark/>

Highlight text.

<Q/>

Quoted text.

<BlockQuote/>

<Time/>

• dateTime prop is supported on web and stripped on native.

Lists

Lists can be used to create basic bulleted or numbered lists. You should try and use universal FlatList or SectionList components for long scrolling lists instead of these.

<UL/>

Create an unordered (bulleted) list <ul /> on web, and emulates the style with a <View /> on native.

• Resets font styles everywhere.
• Supports i18n by reversing format on iOS and Android
• Supports custom bullets

import { UL, LI } from '@expo/html-elements';

export default () => (
  <UL>
    <LI>oranges</LI>
    <LI>apples</LI>
    <UL>
      <LI>green</LI>
      <LI>red</LI>
    </UL>
  </UL>
);

<LI/>

Create a standard list item <li /> on web and a native view on mobile which can render text or views inside it.

Rules

<HR/>

Renders a <View> everywhere. Style is modified to match web.

import { HR } from '@expo/html-elements';

export default () => <HR />;

`

`

Create a line break.

Tables

Create tables universally.

• Each element renders to the expected type on web.
• padding is removed from all table elements.
• Text can only be rendered in TH and TD on mobile.
• colSpan and rowSpan are currently web-only (PRs welcome).

import { Table, THead, TH, TBody, TFoot, TR, TD, Caption } from '@expo/html-elements';
import { Text } from 'react-native';

export default () => (
  <Table>
    <Caption>Caption</Caption>
    <THead>
      <TR>
        <TH colSpan="2">The table header</TH>
      </TR>
    </THead>
    <TBody>
      <TR>
        <TD>The table body</TD>
        <TD>with two columns</TD>
      </TR>
    </TBody>
    <TFoot>
      <TR>
        <TD>
          <Text>This is the table footer</Text>
        </TD>
      </TR>
    </TFoot>
  </Table>
);

Table example output web

<table>
  <caption>
    Caption
  </caption>
  <thead>
    <tr>
      <th colspan="2">The table header</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>The table body</td>
      <td>with two columns</td>
    </tr>
  </tbody>
  <tfoot>
    <tr>
      <td><div>The table body</div></td>
    </tr>
  </tfoot>
</table>

<Table/>

Base element for creating a Table.

<THead/>

Header element in a Table.

<TBody/>

Body element in a Table.

<TFoot/>

Footer element in a Table.

<TH/>

Used to display text in the Header.

• colSpan and rowSpan are currently web-only.

<TR/>

Used to create a Row in a Table.

<TD/>

Create a cell in a Table.

• colSpan and rowSpan are currently web-only.

<Caption/>

Used to caption your table. Excepts text as a child.

TODO

• Improve relative imports for better tree-shaking.

Babel

You can write react-dom elements in your code and use the babel plugin to transform them to @expo/html-elements elements.

// babel.config.js
module.exports = {
  plugins: ['@expo/html-elements/babel'],
};

Input

export default function Page() {
  return (
    <div>
      <h1>Hello World</h1>
    </div>
  );
}

Output

The import is automatically added if it's not already present. All props are passed through without any additional transforms.

import { Div, H1 } from '@expo/html-elements';

export default function Page() {
  return (
    <Div>
      <H1>Hello World</H1>
    </Div>
  );
}

Contributing

Contributions are very welcome! Please refer to guidelines described in the contributing guide.