> To build a Wix site agentically, or add Wix features like bookings or a store to a site you already have, follow https://www.wix.com/headless/skill.md
> 
> Portal Navigation:
> 
> - Append `.md` to any URL under `https://dev.wix.com/docs/` to get its markdown version.
> - Pages are either content pages (article or reference text) or menu pages (a list of links to child pages).
> - To get a menu page, truncate any URL to a parent path and append `.md` (e.g. `https://dev.wix.com/docs/sdk.md`, `https://dev.wix.com/docs/sdk/core-modules.md`).
> - If a reference page seems to be missing its schema (parameters, return types, or type definitions), append `?schema=true` to its `.md` URL (e.g. `https://dev.wix.com/docs/contexts/contexts/stores/category-info/use-category-info-context.md?schema=true`).
> - Top-level index of all portals: https://dev.wix.com/docs/llms.txt
> - Full concatenated docs: https://dev.wix.com/docs/llms-full.txt

## Resource: Page Component

## Article: Page Component

## Article Link: https://dev.wix.com/docs/wix-design-system/components/layout/page/page-component.md

## Article Content:

# Page

_Components/Layout/Page_

Interactive docs page: <https://wix-pages.com/design-system-documentation/#/component/page>

## Overview

```jsx
<Page>
  <Page.Header
    title="Published Events"
    actionsBar={<Button prefixIcon={<Icons.Add />}>Add Event</Button>}
  />
  <Page.Content>
    <Layout>
      <Cell>
        <Card>
          <Card.Content>
            <Box height="300px" />
          </Card.Content>
        </Card>
      </Cell>
    </Layout>
  </Page.Content>
</Page>;
```

Use the page component to build the structure of each page. It's designed for Business Manager applications but can be customized for other use cases too.

### Do

- Use it to build all standard Business Manager pages.
- Customize it as you need for other use cases.

### Don't

- Don't use it to build marketing pages. Use dedicated `<MarketingPageLayout/>` instead.

### Feature examples

#### Structure

This component consists of `<Page.Header/>` and `<Page.Content/>` areas. Both are mandatory in the Business Manager page layout.

```jsx
<Page>
  <Page.Header title="Page Title" />
  <Page.Content>
    <StorybookComponents.Placeholder>
      Page content
    </StorybookComponents.Placeholder>
  </Page.Content>
</Page>;
```

#### Height

Set page height using viewport height unit (`vh`). By default, page height should equal `100vh` (full screen size). If the page has a Business Manager top bar navigation, set the page height to `calc(100vh-48px).`

```jsx
<Page height="50vh">
  <Page.Header title="Page Title" />
  <Page.Content>
    <StorybookComponents.Placeholder>
      Page content
    </StorybookComponents.Placeholder>
  </Page.Content>
</Page>;
```

#### Width

Add constraints to content width with the following props:

- `minWidth` specifies the minimum content width.
- `maxWidth` specifies the maximum content width. When the limit is reached, the side margins stretch and the content aligns to the center of the page.

By default, the page minimum width is 864px and the maximum width is 1248px (plus 48px padding on the sides). These values should be used across all Business Manager pages but can be changed for other use cases.

```jsx
<StorybookComponents.Stack flexDirection="column">
  <Page minWidth={864} maxWidth={1248}>
    <Page.Header
      title="Maximum width"
      subtitle="The maximum width for Business Manager Apps is 1248 pixels."
    />
    <Page.Content>
      <StorybookComponents.Placeholder height="180px" />
    </Page.Content>
  </Page>
  <Page minWidth={864} maxWidth={864}>
    <Page.Header
      title="Minimum width"
      subtitle="Minimum width for Business Manager Apps  is 864 pixels"
    />
    <Page.Content>
      <StorybookComponents.Placeholder height="180px" />
    </Page.Content>
  </Page>
</StorybookComponents.Stack>;
```

#### Side padding

Control left and right content padding with the `sidePadding` prop. The default value is 48px and should be used across all Business Manager pages. The default padding can be changed for other use cases.

```jsx
<StorybookComponents.Stack flexDirection="column">
  <Page sidePadding={48}>
    <Page.Header
      title="Default padding"
      subtitle="The side padding for Business Manager Apps is 48 pixels."
    />
    <Page.Content>
      <StorybookComponents.Placeholder height="180px" />
    </Page.Content>
  </Page>
  <Page sidePadding={240}>
    <Page.Header title="Custom padding" />
    <Page.Content>
      <StorybookComponents.Placeholder height="180px" />
    </Page.Content>
  </Page>
</StorybookComponents.Stack>;
```

#### Background image

Add a background image to the page header with `backgroundImageUrl` prop. Use it to showcase things like services, products or other items you want to feature.

```jsx
<Page backgroundImageUrl="TravelExample1.jpg">
  <Page.Header title="Page with a background image" />
  <Page.Content>
    <Card>
      <Card.Content>
        <StorybookComponents.Placeholder height="180px" />
      </Card.Content>
    </Card>
  </Page.Content>
</Page>;
```

#### Sticky header

The `<Page.Header/>` sticks to the top of the page and minimizes when visitors scroll down. This default behavior can't be changed.

```jsx
<Page height="40vh">
  <Page.Header title="Scroll to minimize page header" />
  <Page.Content>
    <StorybookComponents.Placeholder height="600px" />
  </Page.Content>
</Page>;
```

#### Horizontal scroll

Enable horizontal scroll with the `horizontalScroll` prop.

When visitors scroll, the `<Page.Header/>` stays fixed. Use it when the width of content exceeds the maximum page width. For example, when displaying wide tables or lists.

```jsx
<Page height="40vh" horizontalScroll>
  <Page.Header
    title="Scroll horizontally to view overflow content"
    actionsBar={<Button>Action</Button>}
  />
  <Page.Content>
    <StorybookComponents.Placeholder width="1800px" height="248px">
      Overflow content
    </StorybookComponents.Placeholder>
  </Page.Content>
</Page>;
```

#### Header tail

Pin content below the header by wrapping it into a `<Page.Tail/>` container. Use it for content that needs to be visible at all times, for example a table header in an infinite scroll table.

```jsx
<Page height="40vh">
  <Page.Header title="Scroll to view how the tail sticks" />
  <Page.Tail>
    <StorybookComponents.Placeholder>
      Tail that sticks to page header on scroll
    </StorybookComponents.Placeholder>
  </Page.Tail>
  <Page.Content>
    <StorybookComponents.Placeholder height="1800px" />
  </Page.Content>
</Page>;
```

#### Sticky areas

Wrap page sections into `<Page.Sticky/>` containers to keep a section fixed in position while visitors scroll.

```jsx
<Page height="40vh">
  <Page.Header title="Scroll down to preview sticky area behavior" />
  <Page.Content>
    <Layout>
      <Cell span={8}>
        <StorybookComponents.Placeholder height="3600px" />
      </Cell>
      <Cell span={4}>
        <Page.Sticky>
          <StorybookComponents.Placeholder height="240px">
            Sticky area
          </StorybookComponents.Placeholder>
        </Page.Sticky>
      </Cell>
    </Layout>
  </Page.Content>
</Page>;
```

#### Anchor links

Create anchor links that direct visitors to a place inside the page using references (`ref`) and `onClick` events.

```jsx
() => {
  const ref = React.useRef(null);
  const [downDisabled, setDownDisabled] = React.useState(false);
  const [upDisabled, setUpDisabled] = React.useState(true);

  const onClick = (top) => ref.current.scrollTo({ top, behavior: 'smooth' });
  const onScroll = (props) => {
    if (props.area.y === 'top') {
      setDownDisabled(false);
      setUpDisabled(true);
    }
    if (props.area.y === 'bottom') {
      setDownDisabled(true);
      setUpDisabled(false);
    }
  };

  return (
    <Page
      ref={ref}
      height="50vh"
      scrollProps={{ onScrollAreaChanged: onScroll }}
    >
      <Page.Header
        title="Page with anchor links"
        actionsBar={
          <Button onClick={() => onClick(10000)} disabled={downDisabled}>
            Click to Scroll Down
          </Button>
        }
      />
      <Page.Content>
        <StorybookComponents.Placeholder height="10000px" />
      </Page.Content>
      <Page.FixedFooter>
        <Page.Footer divider>
          <Page.Footer.End>
            <Button
              size="medium"
              onClick={() => onClick(0)}
              disabled={upDisabled}
            >
              Click to Scroll Up
            </Button>
          </Page.Footer.End>
        </Page.Footer>
      </Page.FixedFooter>
    </Page>
  );
};
```

### Common use case examples

#### Empty state

When there's no data to display on a page, use an `<EmptyState/>` with a clear call to action that tells visitors what they should do next.

```jsx
<Page>
  <Page.Header
    title="Categories"
    subtitle="Create and manage categories for your events."
    actionsBar={<Button prefixIcon={<Icons.Add />}>Add Category</Button>}
  />
  <Page.Content>
    <EmptyState
      image={<Image width="120px" src="no_categories.png" transparent />}
      title="Add your first category"
      subtitle="Organize your events with categories. You can connect any event with up to 10 categories."
      theme="page"
    >
      <TextButton prefixIcon={<Icons.Add />}>Add Category</TextButton>
    </EmptyState>
  </Page.Content>
</Page>;
```

#### Tabs

`<Tabs/>` can be used to show more content with the same hierarchy level on the same page. Use `<Page.Tail/>` to fix tabs below the page header so visitors can navigate between content.

```jsx
() => {
  const [activeTabId, setActiveTabId] = React.useState(1);

  return (
    <Page height="60vh">
      <Page.Header
        title="Pricing Plans"
        subtitle="Set up subscriptions, memberships or package plans to sell on your site."
      />
      <Page.Tail>
        <Tabs
          items={[
            { id: 1, title: 'Active plans' },
            { id: 2, title: 'Archived plans' },
          ]}
          type="compactSide"
          activeId={activeTabId}
          onClick={(tab) => setActiveTabId(Number(tab.id))}
        />
      </Page.Tail>
      <Page.Content>
        <Layout>
          {new Array(8).fill(null).map(() => (
            <Cell span={6}>
              <Card>
                <Box height="180px" />
              </Card>
            </Cell>
          ))}
        </Layout>
      </Page.Content>
    </Page>
  );
};
```

#### Form layout: full width

Make sure the form page has "Save" and "Cancel" both at the top and the bottom of the page. Use `<Page.Footer/>` container to store actions at the end of a form.

```jsx
<Page height="60vh">
  <Page.Header
    title="Basic Info"
    actionsBar={
      <Box gap="SP2">
        <Button skin="inverted">Cancel</Button>
        <Button>Save</Button>
      </Box>
    }
    breadcrumbs={
      <Breadcrumbs
        activeId="3"
        items={[
          { id: '1', value: 'Programs' },
          { id: '2', value: 'Healthy Diet' },
          { id: '3', value: 'Basic Info' },
        ]}
      />
    }
    showBackButton
    onBackClicked={() => {}}
  />
  <Page.Content>
    <Layout>
      <Cell>
        <Card>
          <Card.Header title="Program details" />
          <Card.Divider />
          <Card.Content>
            <Box height="420px" />
          </Card.Content>
        </Card>
      </Cell>
      <Cell>
        <Page.Footer divider>
          <Page.Footer.End>
            <Box gap="SP2">
              <Button priority="secondary">Cancel</Button>
              <Button>Save</Button>
            </Box>
          </Page.Footer.End>
        </Page.Footer>
      </Cell>
    </Layout>
  </Page.Content>
</Page>;
```

#### Form layout: two-thirds

For form page layouts, use an 8 column layout and keep 4 columns blank. This makes it easier to scan.

```jsx
() => {
  const renderCard = ({ title, subtitle = undefined }) => (
    <Card>
      <Card.Header title={title} subtitle={subtitle} />
      <Card.Divider />
      <Card.Content>
        <Box height="360px" />
      </Card.Content>
    </Card>
  );

  return (
    <Page height="60vh">
      <Page.Header
        actionsBar={
          <Box gap="SP2">
            <Button skin="inverted">Cancel</Button>
            <Button>Save</Button>
          </Box>
        }
        breadcrumbs={
          <Breadcrumbs
            activeId="2"
            items={[
              { id: '1', value: 'Settings' },
              { id: '2', value: 'eCommerce Settings' },
            ]}
            onClick={() => {}}
          />
        }
        showBackButton
        onBackClicked={() => {}}
        title="eCommerce Settings"
      />

      <Page.Content>
        <Layout>
          <Cell span={8}>
            {renderCard({
              title: 'Orders',
            })}
          </Cell>
          <Cell span={8}>
            {renderCard({
              title: 'Checkout',
              subtitle:
                'Add the checkout fields you need customers to fill out.',
            })}
          </Cell>
          <Cell span={8}>
            {renderCard({
              title: 'Returns',
              subtitle: 'Include more info about your return policy.',
            })}
          </Cell>
          <Cell>
            <Page.Footer divider>
              <Page.Footer.End>
                <Box gap="SP2">
                  <Button priority="secondary">Cancel</Button>
                  <Button>Save</Button>
                </Box>
              </Page.Footer.End>
            </Page.Footer>
          </Cell>
        </Layout>
      </Page.Content>
    </Page>
  );
};
```

#### Form layout: two-thirds with a sidebar column

Use a `<Layout/>` grid to construct a ⅔ form layout that exposes primary and secondary content at the same time. To fix the sidebar's position while scrolling through the main page content, use `<Page.Sticky/>`.

```jsx
() => {
  const renderCard = ({ title, subtitle = undefined, height = '300px' }) => (
    <Card>
      <Card.Header title={title} subtitle={subtitle} />
      <Card.Divider />
      <Card.Content>
        <Box height={height} />
      </Card.Content>
    </Card>
  );

  return (
    <Page height="60vh">
      <Page.Header
        actionsBar={
          <Box gap="SP2">
            <Button skin="inverted">Cancel</Button>
            <Button>Save</Button>
          </Box>
        }
        breadcrumbs={
          <Breadcrumbs
            activeId="2"
            items={[
              { id: '1', value: 'Pricing Plans' },
              { id: '2', value: 'Basic Plan' },
            ]}
            onClick={() => {}}
          />
        }
        showBackButton
        onBackClicked={() => {}}
        title="Basic Plan"
      />
      <Page.Content>
        <Layout>
          <Cell span={8}>
            <Layout>
              <Cell>
                {renderCard({
                  title: 'Plan info',
                  subtitle:
                    'Give your plan a name and sum it up with a tagline.',
                })}
              </Cell>
              <Cell>
                {renderCard({
                  title: 'Connect and manage benefits',
                  subtitle: 'Set up how benefits work in this plan.',
                })}
              </Cell>
              <Cell>
                {renderCard({
                  title: 'Pricing',
                  subtitle: 'How much do you want to charge?',
                })}
              </Cell>
              <Cell>
                {renderCard({
                  title: 'Page permissions',
                  subtitle: 'Manage pages members can access.',
                })}
              </Cell>
              <Cell>
                {renderCard({
                  title: 'Advanced settings',
                })}
              </Cell>
            </Layout>
          </Cell>
          <Cell span={4}>
            <Page.Sticky>
              {renderCard({
                title: 'Plan preview',
                subtitle: 'Preview how your plan appears online.',
                height: '360px',
              })}
            </Page.Sticky>
          </Cell>
          <Cell>
            <Page.Footer divider>
              <Page.Footer.End>
                <Box gap="SP2">
                  <Button priority="secondary">Cancel</Button>
                  <Button>Save</Button>
                </Box>
              </Page.Footer.End>
            </Page.Footer>
          </Cell>
        </Layout>
      </Page.Content>
    </Page>
  );
};
```

#### Table

Use `<Page.Sticky/>` to fix the position of the content to a specific part of the page. For example, fixing the column titles of a table so visitors can sort and filter easily.

```jsx
() => {
  const records = [
    {
      name: 'Light grey hoodie',
      sku: 25232564,
      inStock: true,
      price: '$14.00',
      image: <Image src="ProductExample1.jpg" />,
    },
    {
      name: 'Black watch',
      sku: 35246432,
      inStock: true,
      price: '$29.00',
      image: <Image src="ProductExample2.jpg" />,
    },
    {
      name: 'Reading glasses',
      sku: 4864310,
      inStock: false,
      price: '$69.00',
      image: <Image src="ProductExample3.jpg" />,
    },
    {
      name: 'Leather shoes',
      sku: 125156422,
      inStock: true,
      price: '$7.00',
      image: <Image src="ProductExample4.jpg" />,
    },
    {
      name: 'Light grey hoodie',
      sku: 25232564,
      inStock: true,
      price: '$14.00',
      image: <Image src="ProductExample1.jpg" />,
    },
    {
      name: 'Black watch',
      sku: 35246432,
      inStock: true,
      price: '$29.00',
      image: <Image src="ProductExample2.jpg" />,
    },
    {
      name: 'Reading glasses',
      sku: 4864310,
      inStock: false,
      price: '$69.00',
      image: <Image src="ProductExample3.jpg" />,
    },
    {
      name: 'Leather shoes',
      sku: 125156422,
      inStock: true,
      price: '$7.00',
      image: <Image src="ProductExample4.jpg" />,
    },
  ];

  const Status = ({ isInStock }) => (
    <Text size="small" secondary>
      {isInStock ? 'In stock' : 'Out of stock'}
    </Text>
  );

  const secondaryAction = [
    {
      icon: <Icons.Duplicate />,
      text: 'Duplicate',
      onClick: () => {},
    },
    {
      icon: <Icons.Delete />,
      text: 'Delete',
      onClick: () => {},
    },
  ];

  const columns = [
    {
      title: '',
      render: (row) => row.image,
      width: '60px',
    },
    {
      title: 'Name',
      render: (row) => row.name,
      width: '30%',
    },
    {
      title: 'SKU',
      render: (row) => row.sku,
      width: '20%',
    },
    {
      title: 'Stock',
      render: (row) => <Status isInStock={row.inStock} />,
      width: '20%',
    },
    {
      title: 'Price',
      render: (row) => row.price,
      width: '10%',
    },
    {
      title: '',
      render: (row) => <TableActionCell secondaryActions={secondaryAction} />,
      width: '10%',
    },
  ];

  return (
    <Page height="60vh">
      <Page.Header
        title="Products"
        actionsBar={<Button prefixIcon={<Icons.Add />}>Add Product</Button>}
      />
      <Page.Content>
        <Layout>
          <Cell>
            <Card>
              <Table data={records} columns={columns}>
                <Page.Sticky>
                  <Card>
                    <TableToolbar>
                      <TableToolbar.ItemGroup position="start">
                        <TableToolbar.Item>
                          <TableToolbar.Title>Products</TableToolbar.Title>
                        </TableToolbar.Item>
                      </TableToolbar.ItemGroup>
                    </TableToolbar>
                    <Table.Titlebar />
                  </Card>
                </Page.Sticky>
                <Table.Content titleBarVisible={false} />
              </Table>
            </Card>
          </Cell>
        </Layout>
      </Page.Content>
    </Page>
  );
};
```

#### 2 column list

Use a 2-column page layout to list features, tools or products. This layout works well for items that have relatively long titles and descriptions.

```jsx
() => {
  return (
    <Page height="60vh">
      <Page.Header
        title="SEO Tools"
        subtitle="Optimize your site for search engines so more people can find you online."
        actionsBar={
          <Button skin="inverted" prefixIcon={<Icons.Users />}>
            Hire an SEO Professional
          </Button>
        }
      />
      <Page.Content>
        <Layout>
          <Cell span={6} rows={2}>
            <Card stretchVertically>
              <Card.Content>
                <Box direction="vertical">
                  <Image height="60px" width="60px" />
                </Box>
              </Card.Content>
            </Card>
          </Cell>
          {new Array(8).fill(null).map(() => (
            <Cell span={6}>
              <Card>
                <Card.Content>
                  <Box verticalAlign="middle" gap="SP3">
                    <Image height="60px" width="60px" />
                  </Box>
                </Card.Content>
              </Card>
            </Cell>
          ))}
        </Layout>
      </Page.Content>
    </Page>
  );
};
```

#### 4 column list

Use a grid page layout with 4 columns to display visual items like, menus, categories, collections and photo albums.

```jsx
() => {
  const renderProductItem = ({ image, title }) => (
    <Proportion aspectRatio={1}>
      <MediaOverlay skin="gradient" media={image}>
        <MediaOverlay.Content placement="bottom-start" visible="always">
          <Text weight="normal" light>
            {title}
          </Text>
        </MediaOverlay.Content>
      </MediaOverlay>
    </Proportion>
  );

  return (
    <Page height="60vh">
      <Page.Header
        title="Collections"
        actionsBar={<Button prefixIcon={<Icons.Add />}>Add Collection</Button>}
      />
      <Page.Content>
        <Layout>
          <Cell>
            <Box gap="SP4">
              {renderProductItem({
                image: 'ProductExample1.jpg',
                title: 'Hoodies',
              })}
              {renderProductItem({
                image: 'ProductExample2.jpg',
                title: 'Jewelery and watches',
              })}
              {renderProductItem({
                image: 'ProductExample3.jpg',
                title: 'Accessories',
              })}
              {renderProductItem({
                image: 'ProductExample4.jpg',
                title: 'Shoes',
              })}
            </Box>
          </Cell>
          <Cell>
            <Box gap="SP4">
              {renderProductItem({
                image: 'ProductExample5.jpg',
                title: 'Flowers and plants',
              })}
              {renderProductItem({
                image: 'ProductExample6.jpg',
                title: 'Home',
              })}
              {renderProductItem({
                image: 'ProductExample7.jpg',
                title: 'Winter collection',
              })}
              {renderProductItem({
                image: 'ProductExample8.jpg',
                title: 'Fragrance',
              })}
            </Box>
          </Cell>
        </Layout>
      </Page.Content>
    </Page>
  );
};
```

#### Dashboard

Use a combination of different grids within the same page. This is a great way to display different types of content on one page. Use `<Page.Section/>` to divide content into groups.

```jsx
() => {
  const renderCard = ({ title, height, stretchVertically = false }) => (
    <Card stretchVertically={stretchVertically}>
      <Card.Header title={title} />
      <Card.Divider />
      <Card.Content>
        <Box height={height} />
      </Card.Content>
    </Card>
  );

  const renderToolsCard = () => (
    <Card>
      <Card.Content>
        <Box height="90px" />
      </Card.Content>
    </Card>
  );

  return (
    <Page height="60vh">
      <Page.Header
        title="Facebook Ads"
        actionsBar={
          <PopoverMenu
            triggerElement={
              <Button skin="inverted" suffixIcon={<Icons.ChevronDown />}>
                More Actions
              </Button>
            }
          >
            <PopoverMenu.MenuItem
              text="Edit campaign"
              prefixIcon={<Icons.Edit />}
            />
            <PopoverMenu.MenuItem
              text="Change budget"
              prefixIcon={<Icons.Payment />}
            />
            <PopoverMenu.MenuItem
              text="End campaign"
              prefixIcon={<Icons.Dismiss />}
              skin="destructive"
            />
          </PopoverMenu>
        }
      />
      <Page.Content>
        <Layout>
          <Cell>
            <Card>
              <Box height="120px" />
            </Card>
          </Cell>
          <Cell>
            <Page.Section
              title="Overview"
              showDivider
              actionsBar={
                <Box gap="SP2">
                  <Text>Time Period:</Text>
                  <DropdownBase
                    selectedId={4}
                    options={[
                      { id: 0, value: 'Last hour' },
                      { id: 1, value: 'Last 24 hours' },
                      { id: 2, value: 'Last 7 days' },
                      { id: 3, value: 'Last 30 days' },
                      { id: 4, value: 'Lifetime' },
                    ]}
                  >
                    {({ toggle, selectedOption = {} }) => (
                      <TextButton
                        onClick={toggle}
                        suffixIcon={<Icons.ChevronDown />}
                      >
                        {selectedOption.value}
                      </TextButton>
                    )}
                  </DropdownBase>
                </Box>
              }
            />
          </Cell>
          <Cell span={6}>
            {renderCard({
              title: 'Ad engagement',
              height: '240px',
              stretchVertically: true,
            })}
          </Cell>
          <Cell span={6}>
            {renderCard({
              title: 'Ad impact',
              height: '240px',
            })}
          </Cell>
          <Cell>
            {renderCard({
              title: 'Statistics',
              height: '180px',
            })}
          </Cell>
          <Cell span={4}>
            {renderCard({
              title: 'Audience',
              height: '240px',
            })}
          </Cell>
          <Cell span={4}>
            {renderCard({
              title: 'Performance over time',
              height: '240px',
            })}
          </Cell>
          <Cell span={4}>
            {renderCard({
              title: 'Customer funnel',
              height: '240px',
            })}
          </Cell>
          <Cell>
            <Page.Section
              title="Tools"
              showDivider
              actionsBar={
                <TextButton suffixIcon={<Icons.ChevronRight />}>
                  View All
                </TextButton>
              }
            />
          </Cell>
          <Cell span={3}>{renderToolsCard()}</Cell>
          <Cell span={3}>{renderToolsCard()}</Cell>
          <Cell span={3}>{renderToolsCard()}</Cell>
          <Cell span={3}>{renderToolsCard()}</Cell>
          <Cell span={3}>{renderToolsCard()}</Cell>
          <Cell span={3}>{renderToolsCard()}</Cell>
          <Cell span={3}>{renderToolsCard()}</Cell>
        </Layout>
      </Page.Content>
    </Page>
  );
};
```

## Code

```jsx
import { Page } from '@wix/design-system';
```

### Props

| Name | Type | Default | Description |
| --- | --- | --- | --- |
| `backgroundImageUrl` | `string` | — | Provides a link to the background image source (URL). The image is displayed at the top of the page, underneath the \<Page.Header/>. |
| `children` | `ReactNode` | — | Accepts compound components as child items: - `<Page.Header/>` - `<Page.Content/>` - `<Page.Tail/>` - `<Page.Section/>` - `<Page.Footer/>` |
| `dataHook` | `string` | — | Applies a data-hook HTML attribute that can be used in the tests. |
| `gradientClassName` | `string` | — | Specifies a CSS class name that defines a gradient background for \<Page.Header/>. |
| `height` | `string` | — | Sets the height of the page in pixels (px), viewport height (vh), etc. |
| `horizontalScroll` | `boolean` | — | Enables page content to scroll horizontally when its width exceed maximum allowed width. |
| `maxWidth` *(required)* | `number` | — | Sets the maximum width of the page (paddings excluded) |
| `minWidth` | `number` | — | Sets the minimum width of the page (paddings excluded). When `mobile` is enabled on `<WixDesignSystemProvider/>`, the default minimum width is removed, but an explicitly provided value is still applied. |
| `scrollableContentRef` | `(ref: HTMLElement \| null) => void` | — | Defines a reference called together with page scrollable content ref after page mount. <br/> **Note** - if you need this ref only for listening to scroll events on the scrollable content then use this prop instead: `scrollProps = {onScrollChanged/onScrollAreaChanged}` |
| `scrollProps` *(required)* | `ScrollableContainerCommonProps` | — | Pass properties related to the scrollable content of the page. <br/> **onScrollAreaChanged** - defines a handler function for scroll area changes. Function is triggered when the user scrolls to a different area of the scrollable content. See signature for possible areas: `function({area: {y: AreaY, x: AreaX}, target: HTMLElement}) => void` `AreaY`: top \| middle \| bottom \| none `AreaX`: start \| middle \| end \| none (not implemented yet) <br/> **onScrollAreaChanged** - defines a general handler for scroll changes with throttling (100ms): `function({target: HTMLElement}) => void` |
| `sidePadding` | `number` | — | Sets the side paddings of a page. Also applies when `<Page.Content/>` is `fullScreen`. |
| `verticalPadding` | `number` | — | Sets the top and bottom paddings of the page content in pixels. The top padding applies only when the page has no `<Page.Header/>` or `<Page.Tail/>`, and the bottom padding only when it has no `<Page.FixedFooter/>`. When not set, the content has no top padding and a 48px bottom padding. |
| `zIndex` | `number` | — | Specifies the stack order (z-index) of a page. |

## Testkit

Import the driver matching your test environment:

```jsx
// UniDriver
import { PageUniDriver } from '@wix/design-system/dist/testkit/unidriver';

// Vanilla
import { PageTestkit } from '@wix/design-system/dist/testkit';

// Puppeteer
import { PageTestkit } from '@wix/design-system/dist/testkit/puppeteer';

// Testing Library
import { PageTestkit } from '@wix/design-system/dist/testkit/testing-library';
```

### Driver methods

| Method | Description |
| --- | --- |
| `hasClass` | — |
| `scrollableContainer` | Provides a UniDriver for the page's scrollable container. |
| `backgroundImageExists` | true if header background image exist |
| `gradientClassNameExists` | true if gradient class name exist |
| `tailExists` | true if tail exist in DOM |
| `gradientContainerHeight` | return container height |
| `getPageHtml` | returns html in a string form |
| `exists` | Checks whether the component found with the given data hook. |
| `element` | Gets the component root element. |
| `click` | Clicks on the component root element. |
| `base` | Returns UniDriver for the base element. |

## Changelog

- **1.341.0** (2026-10-22) — maintenance release, no component-specific changes
- **1.340.0** (2026-10-21) — maintenance release, no component-specific changes
- **1.339.0** (2026-10-19) — maintenance release, no component-specific changes
- **1.338.0** (2026-10-15) — maintenance release, no component-specific changes
- **1.337.0** (2026-10-14) — feat: add a `scrollableContainer` property to the UniDriver so tests can access the page's scrollable content. ([#17444](invalid-url))
- **1.336.0** (2026-10-13) — maintenance release, no component-specific changes
- **1.332.0** (2026-10-05) — feat: add `stretchVertically` to `Page.Content`, so content such as a `<Card stretchVertically/>` can fill the page's visible height, and a `verticalPadding` prop to set the content's top and bottom padding. A `sidePadding` set on `Page` now also applies to `fullScreen` content, which previously dropped it. ([#17337](invalid-url)) — has visual changes
- **1.331.0** (2026-10-01) — maintenance release, no component-specific changes
- **1.330.3** (2026-09-29) — maintenance release, no component-specific changes
- **1.330.0** (2026-09-28) — maintenance release, no component-specific changes
- **1.329.0** (2026-09-24) — maintenance release, no component-specific changes
- **1.328.0** (2026-09-22) — maintenance release, no component-specific changes
- **1.325.0** (2026-09-17) — maintenance release, no component-specific changes
- **1.320.0** (2026-09-03) — fix: the page background changed from `#F8F6F6` to `#F7F7F7` in Harmony (odeditor). ([#16941](invalid-url))
- **1.317.0** (2026-08-26) — fix: the content area now shows the standard WDS scrollbar. ([#16867](invalid-url))
- **1.312.0** (2026-08-14) — maintenance release, no component-specific changes
- **1.310.0** (2026-08-10) — maintenance release, no component-specific changes
- **1.307.0** (2026-08-03) — maintenance release, no component-specific changes
- **1.306.0** (2026-07-31) — maintenance release, no component-specific changes
- **1.305.1** (2026-07-30) — maintenance release, no component-specific changes
- **1.299.0** (2026-07-17) — maintenance release, no component-specific changes
- **1.295.0** (2026-07-03) — maintenance release, no component-specific changes
- **1.292.0** (2026-06-22) — maintenance release, no component-specific changes
- **1.291.0** (2026-06-19) — maintenance release, no component-specific changes
- **1.289.0** (2026-06-17) — fix: footer divider hidden in harmony theme ([#16394](invalid-url)) — has visual changes
- **1.285.0** (2026-06-05) — feat: adapt layout when WixDesignSystemProvider is in mobile mode ([#16338](invalid-url)) — has visual changes
- **1.281.0** (2026-05-19) — fix: replace settimeout hack with resizeobserver for header height ([#16293](invalid-url))
- **1.278.0** (2026-05-08) — maintenance release, no component-specific changes
- **1.273.0** (2026-04-30) — maintenance release, no component-specific changes
- **1.272.0** (2026-04-27) — maintenance release, no component-specific changes
- **1.266.0** (2026-04-07) — maintenance release, no component-specific changes
- **1.260.0** (2026-03-17) — maintenance release, no component-specific changes
- **1.258.0** (2026-02-23) — breaking: tokenization + update of update-screenshots script ([#15936](invalid-url))
- **1.256.2** (2026-02-13) — fix: default minWidth is reverted to 960px ([#15920](invalid-url))
- **1.256.1** (2026-02-10) — maintenance release, no component-specific changes
- **1.254.0** (2026-02-03) — maintenance release, no component-specific changes
- **1.252.0** (2026-01-28) — feat: add media query + decrease min-width ([#15873](invalid-url))
- **1.247.2** (2026-01-21) — maintenance release, no component-specific changes
- **1.241.0** (2025-12-17) — maintenance release, no component-specific changes
- **1.240.0** (2025-12-16) — maintenance release, no component-specific changes
- **1.238.0** (2025-12-10) — maintenance release, no component-specific changes
- **1.213.0** (2025-08-19) — maintenance release, no component-specific changes
- **1.197.0** (2025-06-06) — maintenance release, no component-specific changes
- **1.155.0** (2025-01-23) — maintenance release, no component-specific changes
- **1.154.0** (2025-01-17) — maintenance release, no component-specific changes
- **1.144.0** (2024-12-03) — maintenance release, no component-specific changes
- **1.143.0** (2024-11-25) — maintenance release, no component-specific changes
- **1.138.1** (2024-10-30) — maintenance release, no component-specific changes
- **1.123.1** (2024-09-05) — maintenance release, no component-specific changes
- **1.115.0** (2024-07-17) — maintenance release, no component-specific changes
- **1.107.0** (2024-05-29) — maintenance release, no component-specific changes
- **1.104.1** (2024-05-14) — maintenance release, no component-specific changes
- **1.102.0** (2024-04-16) — maintenance release, no component-specific changes
- **1.98.0** (2024-03-15) — fix: fix minWidth prop ([#13459](invalid-url))
- **1.97.2** (2024-03-04) — feat: add usePageContext Support ([#13398](invalid-url))
- **1.97.1** (2024-02-28) — breaking: tokenise ([#13375](invalid-url))
- **1.97.0** (2024-02-26) — maintenance release, no component-specific changes
- **1.96.0** (2024-02-21) — maintenance release, no component-specific changes
- **1.93.1** (2024-02-12) — maintenance release, no component-specific changes
- **1.93.0** (2024-02-08) — maintenance release, no component-specific changes
- **1.92.1** (2024-02-05) — maintenance release, no component-specific changes