superdesk-ui-framework 3.0.0-beta.0 → 3.0.0-rc12

package/app-typescript/components/Select.tsx

@@ -1,17 +1,25 @@
 import * as React from 'react';
-import classNames from 'classnames';
+// import classNames from 'classnames';
 import nextId from "react-id-generator";
+import { InputWrapper } from './Form';
 
 interface ISelect {
     value?: string;
-    label?: string;
+    label: string;
     info?: string;
     error?: string;
     required?: boolean;
     disabled?: boolean;
     invalid?: boolean;
     inlineLabel?: boolean;
+    labelHidden?: boolean;
+    tabindex?: number;
+    fullWidth?: boolean;
     onChange(newValue: string): void;
+    boxedStyle?: boolean;
+    boxedLable?: boolean;
+    placeholder?: string;
+    size?: 'medium' | 'large' | 'x-large';
 }
 
 interface IState {
@@ -20,6 +28,7 @@ interface IState {
 }
 
 class Select extends React.Component<ISelect, IState> {
+    private htmlId = nextId();
     constructor(props: ISelect) {
         super(props);
 
@@ -31,44 +40,35 @@ class Select extends React.Component<ISelect, IState> {
         this.handleChange = this.handleChange.bind(this);
     }
 
-    htmlId = nextId();
-
     handleChange(event: React.ChangeEvent<HTMLSelectElement>) {
         this.setState({ value: event.target.value });
         this.props.onChange(event.target.value);
     }
 
     render() {
-        const classes = classNames('sd-input sd-input--is-select', {
-            'sd-input--inline-label': this.props.inlineLabel,
-            'sd-input--required': this.props.required,
-            'sd-input--disabled': this.props.disabled,
-            'sd-input--invalid': this.props.invalid || this.state.invalid,
-        });
-
         return (
-            <div className={classes}>
-                {this.props.label ?
-                    <label className='sd-input__label' htmlFor={this.htmlId}>{this.props.label}</label> : null}
-
+            <InputWrapper
+            label={this.props.label}
+            error={this.props.error}
+            required={this.props.required}
+            disabled={this.props.disabled}
+            invalid={this.state.invalid}
+            info={this.props.info}
+            inlineLabel={this.props.inlineLabel}
+            labelHidden={this.props.labelHidden}
+            fullWidth={this.props.fullWidth}
+            htmlId={this.htmlId}
+            tabindex={this.props.tabindex}>
                 <select className='sd-input__select'
-                    id={this.htmlId}
-                    value={this.state.value}
-                    aria-label={this.props.label}
-                    aria-describedby={this.htmlId}
-                    onChange={this.handleChange}
-                    disabled={this.props.disabled}>
-                    {this.props.children}
+                id={this.htmlId}
+                value={this.state.value}
+                aria-describedby={this.htmlId}
+                tabIndex={this.props.tabindex}
+                onChange={this.handleChange}
+                disabled={this.props.disabled}>
+                {this.props.children}
                 </select>
-
-                <div className='sd-input__message-box'>
-                    {this.props.info && !this.props.invalid && !this.state.invalid ?
-                        <div className='sd-input__hint'>{this.props.info}</div> : null}
-                    {this.props.invalid || this.state.invalid ?
-                        <div className='sd-input__message'>{this.props.error}</div>
-                        : null}
-                </div>
-            </div>
+            </InputWrapper>
         );
     }
 }

package/app-typescript/components/SelectGrid.tsx

@@ -0,0 +1,233 @@
+import * as  React from 'react';
+import nextId from "react-id-generator";
+import { OverlayPanel } from '@superdesk/primereact/overlaypanel';
+import { Loader } from "./Loader";
+
+/**
+ * @ngdoc react
+ * @name SelectGrid
+ * @description searchable select component with grid view of items
+ */
+
+export interface IItem {
+    value: string;
+    label: string;
+    [extra: string]: any;
+}
+
+interface IProps {
+    getItems(searchString: string | null): Promise<Array<IItem>>;
+    onChange(value: IItem): void;
+    itemTemplate: React.ComponentType<{ item: IItem | null }>;
+    triggerTemplate: React.ComponentType<any>;
+    label: string;
+    filterPlaceholder?: string;
+}
+
+interface IState {
+    items: Array<IItem>;
+    loading: boolean;
+    isOpen: boolean;
+}
+
+export class SelectGrid extends React.PureComponent<IProps, IState> {
+    htmlId = nextId();
+    buttonContainer: React.RefObject<HTMLDivElement>;
+    overlayPanel: React.RefObject<OverlayPanel>;
+    searchInput: React.RefObject<HTMLInputElement>;
+    gridContainer: React.RefObject<HTMLDivElement>;
+
+    constructor(props: IProps) {
+        super(props);
+
+        this.state = { items: [], loading: true, isOpen: false };
+
+        this.buttonContainer = React.createRef();
+        this.overlayPanel = React.createRef();
+        this.searchInput = React.createRef();
+        this.gridContainer = React.createRef();
+    }
+
+    componentDidMount() {
+        this.props.getItems(null).then((items) => {
+            this.setState({ items, loading: false });
+        });
+    }
+
+    componentWillUnmount() {
+        document.removeEventListener('keydown', this.handleKeydown);
+    }
+
+    togglePopup = (event?: React.SyntheticEvent) => {
+        if (!event) {
+            // @ts-ignore
+            this.overlayPanel.current.hide();
+        } else {
+            // @ts-ignore
+            this.overlayPanel.current.toggle(event);
+        }
+
+        setTimeout(() => {
+            // Now that the popup has (dis)appeared handle items and events
+
+            if (this.state.isOpen) {
+                document.removeEventListener('keydown', this.handleKeydown);
+                // @ts-ignore
+                this.buttonContainer.current.querySelector('button')?.focus();
+            } else {
+                document.addEventListener('keydown', this.handleKeydown);
+                this.loadItems();
+                // @ts-ignore
+                this.searchInput.current.focus();
+            }
+
+            this.setState({ isOpen: !this.state.isOpen });
+        });
+
+    }
+
+    search = (event: React.ChangeEvent<HTMLInputElement>) => {
+        const searchString: string = event.target.value.toLowerCase();
+        this.loadItems(searchString);
+    }
+
+    loadItems = (searchString: string | null = null) => {
+        this.setState({ loading: true });
+        this.props.getItems(searchString).then((items) => {
+            this.setState({ items, loading: false });
+        });
+    }
+
+    select = (item: IItem) => {
+        this.props.onChange(item);
+        this.togglePopup();
+    }
+
+    getItemElement = (index: number): HTMLDivElement | null | undefined => {
+        return this.gridContainer.current?.querySelector(`[data-item-index="${index}"]`);
+    }
+
+    handleKeydown = (event: KeyboardEvent) => {
+        const navKeys = [
+            "Enter",
+            "ArrowRight",
+            "ArrowLeft",
+            "ArrowUp",
+            "ArrowDown",
+            "PageDown",
+            "PageUp",
+        ];
+        const activeElement = document.activeElement;
+
+        if (event.code === "Escape") {
+            event.preventDefault();
+            event.stopPropagation();
+            this.togglePopup();
+        } else if (activeElement === this.searchInput?.current) {
+            if (event.code === "ArrowDown") {
+                event.preventDefault();
+                this.getItemElement(0)?.focus();
+            } else if (event.code === "Enter" && this.state.items.length === 1) {
+                event.preventDefault();
+                this.select(this.state.items[0]);
+            }
+            // @ts-ignore
+        } else if (document.activeElement.getAttribute('data-item-index') && navKeys.includes(event.code)) {
+            // @ts-ignore
+            let itemIndex = parseInt(activeElement.getAttribute('data-item-index'), 10);
+
+            // Prevent default behaviour, such as scrolling
+            event.preventDefault();
+            if (event.code === "Enter") {
+                this.select(this.state.items[itemIndex]);
+                return;
+            } else if (event.code === "ArrowRight") {
+                itemIndex += 1;
+            } else if (event.code === "ArrowLeft") {
+                itemIndex -= 1;
+            } else if (event.code === "ArrowDown") {
+                itemIndex += 4;
+            } else if (event.code === "ArrowUp") {
+                if (itemIndex === 0) {
+                    this.searchInput?.current?.focus();
+                    return;
+                }
+                itemIndex -= 4;
+            } else if (event.code === "PageDown") {
+                itemIndex += 16;
+            } else if (event.code === "PageUp") {
+                itemIndex -= 16;
+            }
+
+            if (itemIndex < 0) {
+                itemIndex = 0;
+            } else if (itemIndex >= this.state.items.length) {
+                itemIndex = this.state.items.length - 1;
+            }
+
+            this.getItemElement(itemIndex)?.focus();
+        }
+    }
+
+    render() {
+        const ItemTemplate = this.props.itemTemplate;
+        const TriggerTemplate = this.props.triggerTemplate;
+
+        return (
+            <React.Fragment>
+                <div
+                    className="sd-input sd-input--grid-select"
+                    ref={this.buttonContainer}
+                    aria-label={this.props.label}
+                >
+                    <label className="sd-input__label">
+                        {this.props.label}
+                    </label>
+                    <TriggerTemplate onClick={this.togglePopup} />
+
+                </div>
+                <OverlayPanel
+                    ref={this.overlayPanel}
+                    dismissable={true}
+                    className="select-grid__overlay-panel"
+                    appendTo={document.body} // making it work inside `overflow:hidden`
+                >
+                    <div className="select-grid__panel">
+                        <div className="select-grid__header">
+                            <div className="sd-searchbar sd-searchbar--boxed">
+                                <label className="sd-searchbar__icon" />
+                                <input
+                                    className="sd-searchbar__input"
+                                    placeholder={this.props.filterPlaceholder || 'Search...'}
+                                    type="text"
+                                    onChange={this.search}
+                                    ref={this.searchInput}
+                                />
+                            </div>
+                        </div>
+                        <div
+                            className="select-grid__body"
+                            ref={this.gridContainer}
+
+                        >
+                            <Loader overlay={this.state.loading} />
+                            {this.state.items.map((item, index) => (
+                                <div
+                                    key={this.htmlId + item.label}
+                                    data-item-index={index}
+                                    className="flex-grid__item select-grid__item sd-padding-y--3"
+                                    tabIndex={0}
+                                    role="button"
+                                    aria-label={item.name}
+                                    onClick={() => this.select(item)}
+                                >
+                                    <ItemTemplate item={item} />
+                                </div>
+                            ))}
+                        </div>
+                    </div>
+                </OverlayPanel>
+            </React.Fragment>
+        );
+    }
+}

package/app-typescript/components/SelectWithTemplate.tsx

@@ -1,5 +1,8 @@
 import * as React from 'react';
 import {Dropdown} from '@superdesk/primereact/dropdown';
+// import classNames from 'classnames';
+import nextId from "react-id-generator";
+import { InputWrapper } from './Form';
 
 interface IProps<T> {
     // Don't forget to cancel unfinished requests every the prop is called.
@@ -11,32 +14,41 @@ interface IProps<T> {
     itemTemplate: React.ComponentType<{option: T | null}>;
     noResultsFoundMessage: string;
     filterPlaceholder?: string;
-
     disabled?: boolean;
-    required?: boolean;
     autoFocus?: boolean;
     autoOpen?: boolean; // Avoid using this - the dropdown may cover important elements.
     width?: 'min' | '100%'; // defaults to min
     zIndex?: number;
     'data-test-id'?: string;
+    inlineLabel?: boolean;
+    required?: boolean;
+    fullWidth?: boolean;
+    invalid?: boolean;
+    labelHidden?: boolean;
+    tabindex?: number;
+    label?: string;
+    info?: string;
+    error?: string;
 }
 
 interface IState<T> {
     options: Array<T>;
     loading: boolean;
+    invalid: boolean;
 }
 
 const labelKey = 'label';
 
 export class SelectWithTemplate<T> extends React.Component<IProps<T>, IState<T>> {
     componentRef: Dropdown | null;
-
+    private htmlId = nextId();
     constructor(props: IProps<T>) {
         super(props);
 
         this.state = {
             options: [],
             loading: false,
+            invalid: this.props.invalid ? this.props.invalid : false,
         };
 
         this.componentRef = null;
@@ -87,7 +99,21 @@ export class SelectWithTemplate<T> extends React.Component<IProps<T>, IState<T>>
         const fakePlaceholderWithNonBreakingSpace = ' ';
 
         return (
-            <Dropdown
+            <InputWrapper
+            label={this.props.label}
+            error={this.props.error}
+            required={this.props.required}
+            disabled={this.props.disabled}
+            invalid={this.state.invalid}
+            info={this.props.info}
+            inlineLabel={this.props.inlineLabel}
+            labelHidden={this.props.labelHidden}
+            fullWidth={this.props.fullWidth}
+            htmlId={this.htmlId}
+            tabindex={this.props.tabindex}>
+                <Dropdown
+                inputId={this.htmlId}
+                ariaLabelledBy={this.htmlId + 'label'}
                 value={valueInternal}
                 options={optionsInternal}
                 onChange={(e) => {
@@ -108,7 +134,6 @@ export class SelectWithTemplate<T> extends React.Component<IProps<T>, IState<T>>
                 loading={loading}
                 onFilterInputChange={(searchString) => {
                     this.setState({loading: true});
-
                     getItems(searchString).then((_options) => {
                         this.setState({options: _options, loading: false});
                     });
@@ -117,8 +142,8 @@ export class SelectWithTemplate<T> extends React.Component<IProps<T>, IState<T>>
                 style={width === '100%' ? {display: 'flex', width: '100%'} : {}}
                 ref={(componentRef) => {
                     this.componentRef = componentRef;
-                }}
-            />
+                }}/>
+            </InputWrapper>
         );
     }
 }

package/app-typescript/components/SidebarMenu.tsx

@@ -0,0 +1,68 @@
+import * as React from 'react';
+import { Icon } from './Icon';
+
+interface IProps {
+    items: Array<IItem | 'divider'>;
+}
+
+interface IItem {
+    icon: string;
+    size: 'small' | 'big'; // defaults to 'small'
+    tooltip?: string;
+    active?: boolean;
+}
+
+interface IState {
+    index: number;
+    closeIndex: number;
+}
+
+export class SidebarMenu extends React.PureComponent<IProps, IState> {
+    constructor(props: IProps) {
+        super(props);
+        this.state = {
+            index: -1,
+            closeIndex: -1,
+        };
+        this.handleClick = this.handleClick.bind(this);
+    }
+
+    handleClick(indexNumber: number) {
+        this.setState({
+            index: indexNumber,
+        });
+        if (this.state.index === indexNumber) {
+            this.setState({
+                closeIndex: indexNumber,
+            });
+        }
+    }
+
+    render() {
+        return (
+            <div className='sd-sidebar-menu sd-content-wrapper__left-tabs'>
+                <ul className='authoring-active'>
+                    {this.props.items.map((item, index) => {
+                        if (item === 'divider') {
+                            return (
+                                <li key={index} className='sd-sidebar-menu__spacer'></li>
+                            );
+                        } else {
+                            return (
+                                <li key={index} data-sd-tooltip={item['tooltip']} data-flow='right'>
+                                    <a className={'sd-sidebar-menu__btn' + (index === this.state.closeIndex ? ' sd-sidebar-menu__btn--closed ' : '') + (item['active'] ? ' sd-sidebar-menu__btn--active' : (index === this.state.index ? ' sd-sidebar-menu__btn--active' : ''))}
+                                        onClick={() => this.handleClick(index)}>
+                                        <span className='sd-sidebar-menu__main-icon '>
+                                            <Icon size={item['size']} name={item['icon']} />
+                                        </span>
+                                        <i className='sd-sidebar-menu__helper-icon big-icon--chevron-left'></i>
+                                    </a>
+                                </li>
+                            );
+                        }
+                    })}
+                </ul>
+            </div>
+        );
+    }
+}

package/app-typescript/components/Skeleton.tsx

@@ -0,0 +1,48 @@
+
+import * as  React from 'react';
+import classNames from 'classnames';
+
+interface IProps {
+    shape: string;
+    size: string;
+    width: string;
+    height: string;
+    borderRadius: string;
+    animation: string;
+    style: object;
+    className: string;
+}
+
+export class Skeleton extends React.Component<IProps> {
+    static defaultProps = {
+        shape: 'rectangle',
+        size: null,
+        width: '100%',
+        height: '1.2rem',
+        borderRadius: null,
+        animation: 'wave',
+        style: null,
+        className: null,
+    };
+
+    skeletonStyle() {
+        if (this.props.size) {
+            return { width: this.props.size, height: this.props.size, borderRadius: this.props.borderRadius };
+        } else {
+            return { width: this.props.width, height: this.props.height, borderRadius: this.props.borderRadius };
+        }
+    }
+
+    render() {
+        const skeletonClassName = classNames('p-skeleton p-component', {
+            'p-skeleton-circle': this.props.shape === 'circle',
+            'p-skeleton-none': this.props.animation === 'none',
+        }, this.props.className);
+
+        const style = this.skeletonStyle();
+
+        return (
+            <div style={style} className={skeletonClassName}></div>
+        );
+    }
+}

package/app-typescript/components/SlidingToolbar.tsx

@@ -1,13 +1,19 @@
 import * as React from 'react';
+import classNames from 'classnames';
 
 interface IProps {
-    multi: boolean;
+    side?: 'start' | 'end';
 }
 
 export class SlidingToolbar extends React.PureComponent<IProps> {
     render() {
+        let classes = classNames('sliding-toolbar', {
+            'sliding-toolbar--right': this.props.side === undefined,
+            [`sliding-toolbar--${this.props.side}`]: this.props.side || this.props.side !== undefined,
+
+        });
         return (
-            <div className='subnav__sliding-toolbar'>
+            <div className={classes}>
                 {this.props.children}
             </div>
         );

package/app-typescript/components/Spacer.tsx

@@ -0,0 +1,87 @@
+import * as React from 'react';
+import classNames from 'classnames';
+
+export interface IPropsSpacer {
+    h?: boolean; // horizontal
+    v?: boolean; // vertical
+    gap: '0' | '4' | '8' | '16' | '32' | '64';
+    justifyContent?: 'start' | 'end' | 'center' | 'space-around' | 'space-between' | 'space-evenly' | 'stretch';
+    alignItems?: 'start' | 'end' | 'center' | 'stretch';
+    noGrow?: boolean;
+
+    /**
+     * Will not wrap children in div elements.
+     * `noGrow` prop would then not be relevant.
+     */
+    noWrap?: boolean;
+
+    style?: React.CSSProperties;
+
+    children: Array<React.ReactNode>;
+}
+
+export class Spacer extends React.PureComponent<IPropsSpacer> {
+    constructor(props: IPropsSpacer) {
+        super(props);
+        this.state = {
+            items: [],
+        };
+
+    }
+    render() {
+        const {h, v, gap, justifyContent, alignItems, noGrow, noWrap} = this.props;
+
+        const justifyContentDefault: IPropsSpacer['justifyContent'] = h ? 'space-between' : 'start';
+        const alignItemsDefault: IPropsSpacer['alignItems'] = h ? 'center' : 'start';
+
+        return (
+            <div
+                style={{
+                    display: 'flex',
+                    flexDirection: v ? 'column' : 'row',
+                    gap: `${gap}px`,
+                    justifyContent: justifyContent ?? justifyContentDefault,
+                    alignItems: alignItems ?? alignItemsDefault,
+                    width: noGrow === true ? undefined : '100%',
+                    ...(this.props.style ?? {}),
+                }}
+            >
+                {this.props.children.map((el, i) => noWrap ? el : (
+                    <div
+                        key={i}
+                        style={{
+                            width: noGrow === true ? undefined : '100%',
+                        }}
+                    >
+                        {el}
+                    </div>
+                ))}
+            </div>
+        );
+    }
+}
+
+/**
+ * Renders a standalone spacing block - similar to <br />
+ */
+export interface ISpacerBlock {
+    h?: boolean; // horizontal
+    v?: boolean; // vertical
+    gap: '4' | '8' | '16' | '32' | '64';
+}
+
+export class SpacerBlock extends React.PureComponent<ISpacerBlock> {
+    render() {
+        const {gap, h, v} = this.props;
+
+        return (
+            <span
+                style={{
+                    display: h === true ? 'inline-block' : 'block',
+                    width: h === true ? `${gap}px` : undefined,
+                    height: v === true ? `${gap}px` : undefined,
+                }}
+            />
+        );
+    }
+}

package/app-typescript/components/Spinner.tsx

@@ -0,0 +1,32 @@
+import * as React from 'react';
+import classNames from 'classnames';
+
+class LoadingOverlay extends React.PureComponent {
+    render() {
+        return (
+            <div className="sd-loading-overlay--plain">
+                {this.props.children}
+            </div>
+        );
+    }
+}
+
+interface IProps {
+    size?: 'mini' | 'small' | 'medium' | 'large'; // defaults to 'small'
+}
+
+class Spinner extends React.PureComponent<IProps> {
+    render() {
+        let classes = classNames('sd-spinner', {
+            'sd-spinner--small': this.props.size === undefined,
+            [`sd-spinner--${this.props.size}`]: this.props.size || this.props.size !== undefined,
+        });
+        return (
+            <svg role="progressbar" className={classes} viewBox="0 0 50 50">
+                <circle className="sd-spinner__path" cx="25" cy="25" r="20" fill="none" strokeWidth="5"></circle>
+            </svg>
+        );
+    }
+}
+
+export { Spinner, LoadingOverlay };