@performant-software/semantic-components 0.5.1

package/types/components/MasonryGrid.js.flow

@@ -0,0 +1,202 @@
+// @flow
+
+import React, {
+  useEffect,
+  useState,
+  type Element,
+  type Node
+} from 'react';
+import {
+  Dimmer,
+  Header,
+  Image,
+  Loader,
+  Pagination,
+  Segment,
+  Transition
+} from 'semantic-ui-react';
+import _ from 'underscore';
+import './MasonryGrid.css';
+
+type Item = {
+  alt: string,
+  extra?: Element<any> | string,
+  id: number,
+  image: string,
+  subtitle?: string,
+  title?: string,
+};
+
+type LayoutProps = {
+  children: Array<Node>,
+  columns: number,
+  gap: number
+};
+
+const MasonryLayout = (props: LayoutProps) => {
+  const columnWrapper = {};
+  const result = [];
+
+  // create columns
+  for (let i = 0; i < props.columns; i += 1) {
+    columnWrapper[`column${i}`] = [];
+  }
+
+  // divide children into columns
+  for (let i = 0; i < props.children.length; i += 1) {
+    const columnIndex = i % props.columns;
+    columnWrapper[`column${columnIndex}`].push(
+      <div
+        className='itemContainer'
+        key={i}
+        style={{
+          marginBottom: `${props.gap}px`
+        }}
+      >
+        { props.children[i] }
+      </div>
+    );
+  }
+
+  // wrap children in each column with a div
+  for (let i = 0; i < props.columns; i += 1) {
+    result.push(
+      <div
+        className='column'
+        key={i}
+        style={{
+          marginLeft: `${i > 0 ? props.gap : 0}px`
+        }}
+      >
+        { columnWrapper[`column${i}`] }
+      </div>
+    );
+  }
+
+  return (
+    <div
+      className='masonryGrid'
+    >
+      { result }
+    </div>
+  );
+};
+
+type TileProps = {
+  item: Item,
+  onClick?: (item: any) => void,
+  renderContent?: (item: Item) => Node
+};
+
+const HEIGHT_OFFSET = 350;
+const MIN_HEIGHT = 175;
+
+const MasonryTile = (props: TileProps) => {
+  const [dimmerActive, setDimmerActive] = useState(false);
+  const [height, setHeight] = useState(0);
+
+  /**
+   * Calculate the height of the tile once the component mounts.
+   */
+  useEffect(() => {
+    setHeight(MIN_HEIGHT + Math.ceil(Math.random() * HEIGHT_OFFSET));
+  }, []);
+
+  return (
+    <Dimmer.Dimmable
+      className='item'
+      dimmed={dimmerActive}
+      onClick={() => props.onClick && props.onClick(props.item)}
+      onMouseEnter={() => setDimmerActive(true)}
+      onMouseLeave={() => setDimmerActive(false)}
+      style={{
+        cursor: props.onClick ? 'pointer' : undefined,
+        height: `${height}px`
+      }}
+    >
+      <Transition
+        duration={800}
+        visible={dimmerActive}
+      >
+        <Dimmer.Inner
+          active={dimmerActive}
+        >
+          <Header
+            content={props.item.title}
+            inverted
+            subheader={props.item.subtitle}
+          />
+          { props.item.extra && (
+            <div
+              className='extraContainer'
+            >
+              { props.item.extra }
+            </div>
+          )}
+        </Dimmer.Inner>
+      </Transition>
+      <Image
+        alt={props.item.alt}
+        className='image'
+        src={props.item.image}
+      />
+      { props.renderContent && props.renderContent(props.item) }
+    </Dimmer.Dimmable>
+  );
+};
+
+type Props = {
+  columns: number,
+  gap: number,
+  items: Array<Item>,
+  loading?: boolean,
+  onClick?: (item: any) => void,
+  onPageChange?: (page: number) => void,
+  page: number,
+  pages: number,
+  renderContent?: (item: Item) => Node,
+  renderEmpty?: () => Node
+};
+
+const MasonryGrid = (props: Props) => (
+  <div
+    className='masonry-grid'
+  >
+    <Loader
+      active={props.loading}
+    />
+    <div>
+      <MasonryLayout
+        columns={props.columns}
+        gap={props.gap}
+      >
+        { _.map(props.items, (item, index) => (
+          <MasonryTile
+            key={index}
+            item={item}
+            onClick={props.onClick}
+            renderContent={props.renderContent}
+          />
+        ))}
+      </MasonryLayout>
+      { props.pages > 1 && props.onPageChange && (
+        <Segment
+          basic
+          textAlign='center'
+        >
+          <Pagination
+            activePage={props.page}
+            firstItem={null}
+            lastItem={null}
+            onPageChange={(e, { activePage }) => props.onPageChange && props.onPageChange(activePage)}
+            totalPages={props.pages}
+            size='small'
+          />
+        </Segment>
+      )}
+    </div>
+    { !props.loading && !(props.items && props.items.length) && props.renderEmpty && props.renderEmpty() }
+  </div>
+);
+
+export default MasonryGrid;

package/types/components/MediaGallery.js.flow

@@ -0,0 +1,148 @@
+// @flow
+
+import React, { useState, type Element } from 'react';
+import {
+  Button,
+  Dimmer, Image,
+  Loader,
+  Transition
+} from 'semantic-ui-react';
+import PlayButton from './PlayButton';
+import VideoPlayer from './VideoPlayer';
+import VideoPlayerButton from './VideoPlayerButton';
+import './MediaGallery.css';
+
+type Item = {
+  image?: string,
+  embedded?: boolean,
+  preview?: string,
+  src?: string,
+  type: 'image' | 'video'
+};
+
+type Props = {
+  item: Item,
+  label?: string,
+  loading?: boolean,
+  onClose?: () => void,
+  onNext?: () => void,
+  onPrevious?: () => void,
+  renderContent?: () => Element<any>,
+  visible: boolean
+};
+
+const MediaGallery = (props: Props) => {
+  const [video, setVideo] = useState(false);
+
+  return (
+    <Dimmer
+      active={props.visible}
+      className='media-gallery mediaGallery'
+      page
+    >
+      { props.loading && (
+        <Loader
+          active
+          size='big'
+        />
+      )}
+      { props.item && (
+        <>
+          <Transition
+            animation='fade'
+            mountOnShow={false}
+          >
+            <div
+              className='imageContainer'
+            >
+              <Image
+                src={props.item.image}
+                style={{
+                  objectFit: 'contain'
+                }}
+              />
+              { props.item.type === 'video' && (
+                <PlayButton
+                  onClick={() => setVideo(true)}
+                  style={{
+                    position: 'absolute',
+                    top: '50%'
+                  }}
+                />
+              )}
+            </div>
+          </Transition>
+          { props.renderContent && props.renderContent() }
+          { props.onClose && (
+            <div
+              className='controls top right'
+            >
+              <Button
+                basic
+                circular
+                icon='times'
+                inverted
+                onClick={props.onClose}
+                size='large'
+              />
+            </div>
+          )}
+          { props.label && (
+            <div
+              className='controls top left'
+            >
+              <Button
+                basic
+                content={props.label}
+                inverted
+                size='large'
+              />
+            </div>
+          )}
+          { props.onPrevious && (
+            <div
+              className='controls middle left'
+            >
+              <Button
+                basic
+                disabled={!props.onPrevious}
+                inverted
+                icon='angle left'
+                onClick={props.onPrevious}
+                size='huge'
+              />
+            </div>
+          )}
+          { props.onNext && (
+            <div
+              className='controls middle right'
+            >
+              <Button
+                basic
+                disabled={!props.onNext}
+                inverted
+                icon='angle right'
+                onClick={props.onNext}
+                size='huge'
+              />
+            </div>
+          )}
+          { props.item.src && (
+            <VideoPlayer
+              autoPlay
+              embedded={props.item.embedded}
+              icon={<VideoPlayerButton />}
+              onClose={() => setVideo(false)}
+              open={video}
+              placeholder={props.item.preview}
+              size='huge'
+              video={props.item.src}
+            />
+          )}
+        </>
+      )}
+    </Dimmer>
+  );
+};
+
+export default MediaGallery;

package/types/components/MediaGrid.js.flow

@@ -0,0 +1,74 @@
+// @flow
+
+import React, { useEffect, useState } from 'react';
+import { Image, Loader } from 'semantic-ui-react';
+import _ from 'underscore';
+import './MediaGrid.css';
+
+type Item = {
+  image: string
+};
+
+type Props = {
+  items: Array<Item>,
+  loading?: boolean,
+  onClick?: (item: Item) => void
+};
+
+const MAX_IMAGES = 5;
+
+const MediaGrid = (props: Props) => {
+  const [items, setItems] = useState([]);
+
+  /**
+   * Grab the list of image URLs to display and save it on the sate.
+   */
+  useEffect(() => {
+    const list = [];
+
+    for (let i = 0; i < props.items.length && list.length < MAX_IMAGES; i += 1) {
+      if (!_.isEmpty(props.items[i].image)) {
+        list.push(props.items[i]);
+      }
+    }
+
+    setItems(list);
+  }, [props.items]);
+
+  // Return null if no items are passed
+  if (_.isEmpty(props.items)) {
+    return null;
+  }
+
+  return (
+    <div
+      className='mediaGrid'
+    >
+      <Loader
+        active={props.loading}
+      />
+      <div
+        className={`grid${items.length}`}
+      >
+        { _.map(items, (item, index) => (
+          <div
+            className='mediaImage'
+            key={index}
+          >
+            <Image
+              onClick={() => props.onClick && props.onClick(item)}
+              src={item.image}
+              style={{
+                cursor: props.onClick ? 'pointer' : undefined,
+                objectFit: 'cover',
+                width: '100%'
+              }}
+            />
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+};
+
+export default MediaGrid;

package/types/components/MediaList.js.flow

@@ -0,0 +1,98 @@
+// @flow
+
+import React, { type Element } from 'react';
+import { InfiniteScroll } from '@performant-software/shared-components';
+import { Card, Image } from 'semantic-ui-react';
+import _ from 'underscore';
+import ListLoader from './ListLoader';
+import PlayButton from './PlayButton';
+import './MediaList.css';
+
+type Item = {
+  ...any,
+  image: string,
+  type: 'image' | 'video'
+};
+
+type Props = {
+  items: Array<Item>,
+  loading?: boolean,
+  onBottomReached: () => void,
+  onClick: (item: any, index: number) => void,
+  renderDescription?: (item: Item) => Element<any>,
+  renderExtra?: (item: Item) => Element<any>,
+  renderHeader?: (item: Item) => Element<any>,
+  renderMeta?: (item: Item) => Element<any>,
+  textAlign?: 'left' | 'center' | 'right'
+};
+
+const MediaList = (props: Props) => (
+  <InfiniteScroll
+    offset={100}
+    onBottomReached={props.onBottomReached}
+  >
+    <ListLoader
+      active={props.loading || false}
+    />
+    <Card.Group
+      doubling
+      stackable
+    >
+      { _.map(props.items, (item, i) => (
+        <Card
+          onClick={props.onClick.bind(this, item, i)}
+        >
+          <Image
+            src={item.image}
+            style={{
+              objectFit: 'cover'
+            }}
+          />
+          { item.type === 'video' && (
+            <div
+              style={{
+                position: 'absolute',
+                top: '50%',
+                left: '50%',
+                transform: 'translate(-50%, -50%)'
+              }}
+            >
+              <PlayButton />
+            </div>
+          )}
+          { (props.renderMeta || props.renderHeader || props.renderDescription) && (
+            <Card.Content>
+              { props.renderHeader && (
+                <Card.Header
+                  content={props.renderHeader(item)}
+                  textAlign={props.textAlign}
+                />
+              )}
+              { props.renderMeta && (
+                <Card.Meta
+                  content={props.renderMeta(item)}
+                  textAlign={props.textAlign}
+                />
+              )}
+              { props.renderDescription && (
+                <Card.Description
+                  content={props.renderDescription(item)}
+                  textAlign={props.textAlign}
+                />
+              )}
+            </Card.Content>
+          )}
+          { props.renderExtra && (
+            <Card.Content
+              content={props.renderExtra(item)}
+              extra
+              textAlign={props.textAlign}
+            />
+          )}
+        </Card>
+      ))}
+    </Card.Group>
+  </InfiniteScroll>
+);
+
+export default MediaList;

package/types/components/MenuBar.js.flow

@@ -0,0 +1,77 @@
+// @flow
+
+import React, { useCallback } from 'react';
+import {
+  Dropdown,
+  Menu,
+  type DropdownItemProps,
+  type HeaderProps,
+  type MenuProps
+} from 'semantic-ui-react';
+import _ from 'underscore';
+import DropdownMenu from './DropdownMenu';
+
+type Props = MenuProps & {
+  header: HeaderProps,
+  items: Array<DropdownItemProps | MenuProps>
+};
+
+const MenuBar = ({ header, items, ...props }: Props) => {
+  /**
+   * Renders the passed item as a dropdown item.
+   *
+   * @param item
+   *
+   * @returns {JSX.Element}
+   */
+  const renderDropdownItem = useCallback((item) => (
+    <Dropdown.Item {...item} />
+  ), []);
+
+  /**
+   * Renders the passed item as a menu item.
+   *
+   * @returns {JSX.Element}
+   */
+  const renderMenuItem = useCallback((item) => (
+    <Menu.Item
+      {...item}
+    />
+  ), []);
+
+  /**
+   * Renders the passed item as a dropdown menu.
+   *
+   * @returns {JSX.Element}
+   */
+  const renderDropdown = useCallback((item) => (
+    <DropdownMenu
+      item
+      text={item.content}
+    >
+      { _.map(item.items, (i) => (i.items ? renderDropdown(i) : renderDropdownItem(i)))}
+    </DropdownMenu>
+  ), []);
+
+  /**
+   * Renders the passed item.
+   *
+   * @returns {JSX.Element}
+   */
+  const renderItem = useCallback((item) => (item.items ? renderDropdown(item) : renderMenuItem(item)), []);
+
+  return (
+    <Menu
+      {...props}
+      className='menu-bar'
+    >
+      <Menu.Item
+        {...header}
+        header
+      />
+      { _.map(items, (item) => renderItem(item)) }
+    </Menu>
+  );
+};
+
+export default MenuBar;

package/types/components/MenuSidebar.js.flow

@@ -0,0 +1,72 @@
+// @flow
+
+import React, { useCallback } from 'react';
+import {
+  Header,
+  Menu,
+  type HeaderProps,
+  type MenuItemProps, Ref
+} from 'semantic-ui-react';
+import _ from 'underscore';
+
+type Props = {
+  header: HeaderProps,
+  items: Array<HeaderProps | MenuItemProps>
+};
+
+const MenuSidebar = ({ header, items, ...props }: Props) => {
+  /**
+   * Renders the passed item as a menu.
+   *
+   * @type {unknown}
+   */
+  const renderMenu = useCallback((item) => (
+    <Menu.Item>
+      <Menu.Header
+        {...item}
+      />
+      <Menu.Menu>
+        { _.map(item.items, (i) => renderItem(i)) }
+      </Menu.Menu>
+    </Menu.Item>
+  ), []);
+
+  /**
+   * Renders the passed item as a menu item.
+   *
+   * @type {unknown}
+   */
+  const renderMenuItem = useCallback((item) => (
+    <Menu.Item
+      {...item}
+    />
+  ), []);
+
+  /**
+   * Renders the passed item.
+   *
+   * @type {function(*): *}
+   */
+  const renderItem = useCallback((item) => (item.items ? renderMenu(item) : renderMenuItem(item)), []);
+
+  return (
+    <Ref
+      innerRef={props.contextRef}
+    >
+      <Menu
+        {...props}
+        fixed='left'
+        vertical
+      >
+        <Menu.Item>
+          <Header
+            {...header}
+          />
+        </Menu.Item>
+        { _.map(items, (item) => renderItem(item)) }
+      </Menu>
+    </Ref>
+  );
+};
+
+export default MenuSidebar;