---
title: SkeletonText
description: |-
  SkeletonText is used to provide a low fidelity representation of text content before it appears on the page. 

  Optionally you can use any text content inside `SkeletonText` to be used as a base for the rendered skeleton
api_version: 2023-10
api_name: checkout-ui-extensions
source_url:
  html: https://shopify.dev/docs/api/checkout-ui-extensions/2023-10/components/skeletontext
  md: https://shopify.dev/docs/api/checkout-ui-extensions/2023-10/components/skeletontext.md
---

# Skeleton​Text

SkeletonText is used to provide a low fidelity representation of text content before it appears on the page.

Optionally you can use any text content inside `SkeletonText` to be used as a base for the rendered skeleton

## SkeletonTextProps

* inlineSize

  Extract\<Size, 'small' | 'base' | 'large'>

  Adjust the length of the text when no children are passed.

* size

  TextSize

  Size of the text the skeleton replaces.

* id

  string

  A unique identifier for the component.

### Size

```ts
'extraSmall' | 'small' | 'base' | 'large' | 'extraLarge' | 'fill'
```

### TextSize

```ts
Extract<Size, 'extraSmall' | 'small' | 'base' | 'large' | 'extraLarge'> | 'medium'
```

### Examples

* #### Basic SkeletonText

  ##### React

  ```tsx
  import {
    reactExtension,
    SkeletonText,
  } from '@shopify/ui-extensions-react/checkout';

  export default reactExtension(
    'purchase.checkout.block.render',
    () => <Extension />,
  );

  function Extension() {
    return <SkeletonText />;
  }
  ```

  ##### JS

  ```js
  import {extension, SkeletonText} from '@shopify/ui-extensions/checkout';

  export default extension('purchase.checkout.block.render', (root) => {
    const skeletonText = root.createComponent(SkeletonText);

    root.appendChild(skeletonText);
  });
  ```

## Preview

![](https://shopify.dev/images/templated-apis-screenshots/checkout-ui-extensions/2023-10/skeletontext-default.png)

## Examples

### Examples

* #### Using skeleton loaders to prevent layout shifts on content load.

  ##### Description

  When adding content to a layout, incorporate a skeleton loader that renders the approximate size and position of the content during loading. This will provide a seamless transition from skeleton loaders to the content, and prevent any layout shift when the resulting content loads.

  ##### React

  ```jsx
  import {
    reactExtension,
    View,
    BlockStack,
    InlineLayout,
    SkeletonImage,
    Image,
    Icon,
    SkeletonText,
    Text,
  } from '@shopify/ui-extensions-react/checkout';

  export default reactExtension(
    'purchase.checkout.block.render',
    () => <LoadingStateSkeletons />,
  );

  export const Thumbnail = ({
    source = 'https://yourawesomeimage.com',
  }) => (
    <View
      minBlockSize={64}
      cornerRadius="large"
      maxInlineSize={64}
      minInlineSize={64}
      border="base"
    >
      {source ? (
        <Image
          fit="cover"
          aspectRatio={1}
          source={source}
          cornerRadius="large"
        />
      ) : (
        <View maxInlineSize={33}>
          <Icon source="camera" size="fill" />
        </View>
      )}
    </View>
  );
  export const LoadingStateSkeletons = () => {
    const loading = true;
    const [item1, item2] = [
      {
        title: 'Felipe Toledo WildFire',
        variantTitle: 'Medium',
        price: '$330.00',
      },
      {
        title: 'Roller',
        variantTitle: 'Medium',
        price: '$248.00',
      },
    ];
    const itemInfo = ({title, variantTitle}) =>
      loading ? (
        <>
          <SkeletonText>{title}</SkeletonText>
          <SkeletonText>
            {variantTitle}
          </SkeletonText>
        </>
      ) : (
        <>
          <Text emphasis="bold">{title}</Text>
          <Text appearance="subdued">
            {variantTitle}
          </Text>
        </>
      );
    const order = (item) => (
      <InlineLayout
        columns={['auto', 'fill', 'auto']}
        spacing="base"
        blockAlignment="center"
      >
        {loading ? (
          <SkeletonImage
            blockSize={64}
            inlineSize={64}
          />
        ) : (
          <Thumbnail />
        )}
        <BlockStack spacing="extraTight">
          {itemInfo(item)}
        </BlockStack>
        {loading ? (
          <SkeletonText>{item.price}</SkeletonText>
        ) : (
          <Text emphasis="bold">{item.price}</Text>
        )}
      </InlineLayout>
    );
    return (
      <View maxInlineSize={400}>
        <BlockStack>
          {order(item1)}
          {order(item2)}
        </BlockStack>
      </View>
    );
  };
  ```

  ##### JavaScript

  ```js
  import {
    extension,
    BlockStack,
    View,
    InlineLayout,
    Image,
    Icon,
    Text,
    SkeletonImage,
    SkeletonText,
  } from '@shopify/ui-extensions/checkout';

  export default extension(
    'purchase.checkout.block.render',
    (root) => {
      const source = 'https://yourawesomeimage.com';
      const loading = true;
      const [item1, item2] = [
        {
          title: 'Felipe Toledo WildFire',
          variantTitle: 'Medium',
          price: '$330.00',
        },
        {
          title: 'Roller',
          variantTitle: 'Medium',
          price: '$248.00',
        },
      ];
      const thumbnail = root.createComponent(
        View,
        {
          minBlockSize: 64,
          cornerRadius: 'large',
          maxInlineSize: 64,
          minInlineSize: 64,
          border: 'base',
        },
        [
          source
            ? root.createComponent(Image, {
                fit: 'cover',
                aspectRatio: 1,
                source,
                cornerRadius: 'large',
              })
            : root.createComponent(
                View,
                {maxInlineSize: 33},
                [
                  root.createComponent(Icon, {
                    source: 'camera',
                    size: 'fill',
                  }),
                ],
              ),
        ],
      );
      const itemInfo = ({title, variantTitle}) =>
        root.createComponent(
          BlockStack,
          {
            spacing: 'extraTight',
          },
          [
            loading
              ? (root.createComponent(
                  SkeletonText,
                  {},
                  title,
                ),
                root.createComponent(
                  SkeletonText,
                  {},
                  variantTitle,
                ))
              : (root.createComponent(
                  Text,
                  {},
                  title,
                ),
                root.createComponent(
                  Text,
                  {},
                  variantTitle,
                )),
          ],
        );
      const order = (item) =>
        root.createComponent(
          InlineLayout,
          {
            columns: ['auto', 'fill', 'auto'],
            spacing: 'base',
            blockAlignment: 'center',
          },
          [
            loading
              ? root.createComponent(
                  SkeletonImage,
                  {
                    blockSize: 64,
                    inlineSize: 64,
                  },
                )
              : thumbnail,
            itemInfo(item),
            loading
              ? root.createComponent(
                  SkeletonText,
                  {},
                  item.price,
                )
              : root.createComponent(
                  Text,
                  {},
                  item.price,
                ),
          ],
        );
      const view = root.createComponent(
        View,
        {
          maxInlineSize: 400,
        },
        [
          root.createComponent(BlockStack, {}, [
            order(item1),
            order(item2),
          ]),
        ],
      );
      root.appendChild(view);
    },
  );
  ```

## Preview

![](https://shopify.dev/images/templated-apis-screenshots/checkout-ui-extensions/2023-10/loading-skeletons.gif)