Docs/Primitives/createLayoutGroup

createLayoutGroup

Two primitives back the <LayoutGroup> component.

`createLayoutGroup()`

Reads the surrounding layout-group context and returns { forceRender }. Call forceRender() to remeasure layout-animated descendants after DOM changes the projection tree would not otherwise notice, such as route changes or third-party list reorders.

import { createLayoutGroup } from 'motion-solidjs'
import { onMount } from 'solid-js'

function GalleryShell() {
  const { forceRender } = createLayoutGroup()

  onMount(() => {
    window.addEventListener('orientationchange', forceRender)
  })

  return <Gallery />
}

`createLayoutGroupProvider(props)`

The low-level provider half. It establishes a layout-group context for descendants and returns the resolved { id, group, forceRender, key }. <LayoutGroup> wraps this internally; most apps should use the component.

import { createLayoutGroupProvider } from 'motion-solidjs'

function CustomBoundary(props) {
  createLayoutGroupProvider({ id: 'gallery', inherit: 'group' })
  return <>{props.children}</>
}

layoutId

🍅

shared-layout-tabs.tsxOpen ↗

import { AnimatePresence, motion } from 'motion-solidjs'
import { For, Show, createSignal } from 'solid-js'

export const meta = {
  slug: 'shared-layout-tabs',
  title: 'Shared layout — tabs',
  category: 'layout',
  description: 'layoutId slides the active underline; AnimatePresence swaps the body.',
  tag: 'layoutId',
} as const

const tabs = [
  { id: 'tomato', icon: '🍅', label: 'Tomato' },
  { id: 'lettuce', icon: '🥬', label: 'Lettuce' },
  { id: 'cheese', icon: '🧀', label: 'Cheese' },
] as const

type TabId = (typeof tabs)[number]['id']

export default function SharedLayoutTabs() {
  const [active, setActive] = createSignal<TabId>('tomato')
  const selected = () => tabs.find((t) => t.id === active())!

  return (
    <div class="flex w-72 flex-col overflow-hidden rounded-2xl border border-border bg-card">
      <nav class="border-b border-border px-1.5 pt-1.5">
        <ul class="flex gap-1" style={{ 'list-style': 'none', padding: 0, margin: 0 }}>
          <For each={tabs}>
            {(t) => (
              <motion.li
                class="relative flex flex-1 cursor-pointer items-center justify-center gap-1.5 rounded-t-lg px-3 py-2 text-xs font-medium select-none"
                initial={false}
                animate={{
                  backgroundColor:
                    t.id === active() ? 'rgba(255,255,255,0.06)' : 'rgba(255,255,255,0)',
                }}
                onClick={() => setActive(t.id)}
              >
                <span>{t.icon}</span>
                <span>{t.label}</span>
                <Show when={t.id === active()}>
                  <motion.span
                    layoutId="shared-layout-tabs-underline"
                    class="absolute right-0 -bottom-px left-0 h-[2px] bg-grad-rose"
                    transition={{ type: 'spring', stiffness: 380, damping: 30 }}
                  />
                </Show>
              </motion.li>
            )}
          </For>
        </ul>
      </nav>
      <main class="flex h-32 items-center justify-center">
        <AnimatePresence mode="wait">
          <Show when={selected()} keyed>
            {(tab) => (
              <motion.div
                initial={{ y: 10, opacity: 0 }}
                animate={{ y: 0, opacity: 1 }}
                exit={{ y: -10, opacity: 0 }}
                transition={{ duration: 0.2 }}
                class="text-6xl"
              >
                {tab.icon}
              </motion.div>
            )}
          </Show>
        </AnimatePresence>
      </main>
    </div>
  )
}

Use these primitives when you need to compose groups manually or connect a non-component boundary, such as a route transition or portal, to the projection tree.