readme.md

 Svelte Bricks

Naive implementation in Svelte without column balancing. Live demo

Installation

npm install --dev svelte-bricks

Usage

The kitchen sink for this component looks something like this:

<script>
  import Masonry from 'svelte-bricks'

  let nItems = 30
  $: items = [...Array(nItems).keys()]

  let [minColWidth, maxColWidth, gap] = [200, 800, 20]
  let width, height
</script>

Masonry size: <span>{width}px</span> &times; <span>{height}px</span> (w &times;
h)

<Masonry
  {items}
  {minColWidth}
  {maxColWidth}
  {gap}
  let:item
  bind:masonryWidth={width}
  bind:masonryHeight={height}
>
  <Some {item} />
</Masonry>

Note: If items is an array of objects, this component tries to access an id property on each item. This value is used to tell items apart in the keyed {#each} block that creates the masonry layout. Without it, Svelte could not avoid duplicates when new items are added or existing ones rearranged. Read the Svelte docs for details. To change the name of the identifier key, pass idKey="some-uniq-key. Or pass a function getId = (item: Item) => string | number that maps items to unique IDs.

Hint: Balanced columns can be achieved even with this simple implementation if masonry items are allowed to stretch to the column height.

Props

Masonry.svelte expects an array of items as well as a <slot /> component used to render each of the items. The array can contain whatever data (objects, strings, numbers) as long as the slot component knows how to handle it.

Additional optional props are:

1. animate: boolean = true

   Whether to FLIP-animate masonry items when viewport resizing or other events cause items to rearrange.

2. calcCols = (
     masonryWidth: number,
     minColWidth: number,
     gap: number,
   ): number => {
     return Math.min(
       items.length,
       Math.floor((masonryWidth + gap) / (minColWidth + gap)) || 1,
     )
   }

   Function used to compute the number of columns based on the masonry width, minimum column width and gap.

3. class: string = ``

   Applies to the outer div wrapping all masonry columns. For use with CSS frameworks like Tailwind.

4. columnClass: string = ``

   Applies to each column div.

5. duration: number = 200

   Transition duration in milli seconds when masonry items are rearranged or added/removed. Set to 0 to disable transitions.

6. gap: number = 20

   Gap between columns and items within each column in px.

7. getId = (item: Item): string | number => {
     if (typeof item === `number`) return item
     if (typeof item === `string`) return item
     return item[idKey]
   }

   Custom function that maps masonry items to unique IDs of type string or number.

8. idKey: string = `id`

   Name of the attribute to use as identifier if items are objects.

9. items: Item[]

   The only required prop are the list of items to render where Item = $$Generic is a generic type which usually will be object but can also be simple types string or number.

10. masonryHeight: number = 0

    The masonry divs height in px.

11. masonryWidth: number = 0

    The masonry divs width in px.

12. maxColWidth: number = 500

    Maximum column width in px.

13. minColWidth: number = 330

    Minimum column width in px.

14. style: string = ``

    Inline styles that will be applied to the top-level div.masonry.

Styling

Besides inline CSS which you can apply through the style prop, the following :global() CSS selectors can be used for fine-grained control of wrapper and column styles:

:global(div.masonry) {
  /* top-level wrapper div */
}
:global(div.masonry div.col) {
  /* each column in the masonry layout */
}