@wordpress/components 19.7.0 → 19.8.2

package/src/base-control/stories/index.tsx

@@ -0,0 +1,80 @@
+/**
+ * External dependencies
+ */
+import type { ComponentMeta, ComponentStory } from '@storybook/react';
+
+/**
+ * Internal dependencies
+ */
+import BaseControl from '..';
+import Button from '../../button';
+
+const meta: ComponentMeta< typeof BaseControl > = {
+	title: 'Components/BaseControl',
+	component: BaseControl,
+	argTypes: {
+		children: { control: { type: null } },
+		help: { control: { type: 'text' } },
+		label: { control: { type: 'text' } },
+	},
+	parameters: {
+		controls: { expanded: true },
+		docs: { source: { state: 'open' } },
+	},
+};
+export default meta;
+
+const BaseControlWithTextarea: ComponentStory< typeof BaseControl > = ( {
+	id,
+	...props
+} ) => {
+	return (
+		<BaseControl id={ id } { ...props }>
+			<textarea style={ { display: 'block' } } id={ id } />
+		</BaseControl>
+	);
+};
+
+export const Default: ComponentStory<
+	typeof BaseControl
+> = BaseControlWithTextarea.bind( {} );
+Default.args = {
+	__nextHasNoMarginBottom: true,
+	id: 'textarea-default-1',
+	label: 'Label text',
+};
+
+export const WithHelpText = BaseControlWithTextarea.bind( {} );
+WithHelpText.args = {
+	...Default.args,
+	id: 'textarea-with-help-text-1',
+	help: 'Help text adds more explanation.',
+};
+
+/**
+ * `BaseControl.VisualLabel` is used to render a purely visual label inside a `BaseControl` component.
+ *
+ * It should only be used in cases where the children being rendered inside `BaseControl` are already accessibly labeled,
+ * e.g., a button, but we want an additional visual label for that section equivalent to the labels `BaseControl` would
+ * otherwise use if the `label` prop was passed.
+ */
+export const WithVisualLabel: ComponentStory< typeof BaseControl > = (
+	props
+) => {
+	BaseControl.VisualLabel.displayName = 'BaseControl.VisualLabel';
+
+	return (
+		<BaseControl { ...props }>
+			<BaseControl.VisualLabel>Visual label</BaseControl.VisualLabel>
+			<div>
+				<Button variant="secondary">Select an author</Button>
+			</div>
+		</BaseControl>
+	);
+};
+WithVisualLabel.args = {
+	...Default.args,
+	help: 'This button is already accessibly labeled.',
+	id: undefined,
+	label: undefined,
+};

package/src/base-control/types.ts

@@ -0,0 +1,42 @@
+/**
+ * External dependencies
+ */
+import type { ReactNode } from 'react';
+
+export type BaseControlProps = {
+	/**
+	 * Start opting into the new margin-free styles that will become the default in a future version.
+	 *
+	 * @default false
+	 */
+	__nextHasNoMarginBottom?: boolean;
+	/**
+	 * The HTML `id` of the element (passed in as a child to `BaseControl`) to which labels and help text are being generated.
+	 * This is necessary to accessibly associate the label with that element.
+	 */
+	id?: string;
+	/**
+	 * If this property is added, a help text will be generated using help property as the content.
+	 */
+	help?: ReactNode;
+	/**
+	 * If this property is added, a label will be generated using label property as the content.
+	 */
+	label?: ReactNode;
+	/**
+	 * If true, the label will only be visible to screen readers.
+	 *
+	 * @default false
+	 */
+	hideLabelFromVision?: boolean;
+	className?: string;
+	/**
+	 * The content to be displayed within the `BaseControl`.
+	 */
+	children: ReactNode;
+};
+
+export type BaseControlVisualLabelProps = {
+	className?: string;
+	children: ReactNode;
+};

package/src/border-box-control/border-box-control/README.md

@@ -0,0 +1,178 @@
+# BorderBoxControl
+
+<div class="callout callout-alert">
+This feature is still experimental. “Experimental” means this is an early implementation subject to drastic and breaking changes.
+</div>
+<br />
+
+This component provides users with the ability to configure a single "flat"
+border or separate borders per side.
+
+## Development guidelines
+
+The `BorderBoxControl` effectively has two view states. The first, a "linked"
+view, allows configuration of a flat border via a single `BorderControl`.
+The second, a "split" view, contains a `BorderControl` for each side
+as well as a visualizer for the currently selected borders. Each view also
+contains a button to toggle between the two.
+
+When switching from the "split" view to "linked", if the individual side
+borders are not consistent, the "linked" view will display any border properties
+selections that are consistent while showing a mixed state for those that
+aren't. For example, if all borders had the same color and style but different
+widths, then the border dropdown in the "linked" view's `BorderControl` would
+show that consistent color and style but the "linked" view's width input would
+show "Mixed" placeholder text.
+
+## Usage
+
+```jsx
+import { __experimentalBorderBoxControl as BorderBoxControl } from '@wordpress/components';
+import { __ } from '@wordpress/i18n';
+
+const colors = [
+	{ name: 'Blue 20', color: '#72aee6' },
+	// ...
+];
+
+const MyBorderBoxControl = () => {
+	const defaultBorder = {
+		color: '#72aee6',
+		style: 'dashed',
+		width: '1px',
+	};
+	const [ borders, setBorders ] = useState( {
+		top: defaultBorder,
+		right: defaultBorder,
+		bottom: defaultBorder,
+		left: defaultBorder,
+	} );
+	const onChange = ( newBorders ) => setBorders( newBorders );
+
+	return (
+		<BorderBoxControl
+			colors={ colors }
+			label={ __( 'Borders' ) }
+			onChange={ onChange }
+			value={ borders }
+		/>
+	);
+};
+```
+
+If you're using this component outside the editor, you can
+[ensure `Tooltip` positioning](/packages/components/README.md#popovers-and-tooltips)
+for the `BorderBoxControl`'s color and style options, by rendering your
+`BorderBoxControl` with a `Popover.Slot` further up the element tree and within
+a `SlotFillProvider` overall.
+
+## Props
+
+### `colors`: `Array`
+
+An array of color definitions. This may also be a multi-dimensional array where
+colors are organized by multiple origins.
+
+Each color may be an object containing a `name` and `color` value.
+
+- Required: No
+
+### `disableCustomColors`: `boolean`
+
+This toggles the ability to choose custom colors.
+
+- Required: No
+
+### `enableAlpha`: `boolean`
+
+This controls whether the alpha channel will be offered when selecting
+custom colors.
+
+- Required: No
+
+### `enableStyle`: `boolean`
+
+This controls whether to support border style selections.
+
+- Required: No
+- Default: `true`
+
+### `hideLabelFromVision`: `boolean`
+
+Provides control over whether the label will only be visible to screen readers.
+
+- Required: No
+
+### `label`: `string`
+
+If provided, a label will be generated using this as the content.
+
+_Whether it is visible only to screen readers is controlled via
+`hideLabelFromVision`._
+
+- Required: No
+
+### `onChange`: `( value?: Object ) => void`
+
+A callback function invoked when any border value is changed. The value received
+may be a "flat" border object, one that has properties defining individual side
+borders, or `undefined`.
+
+_Note: The will be `undefined` if a user clears all borders._
+
+- Required: Yes
+
+### `popoverClassNames`: `Object`
+
+An object defining CSS classnames for all the inner `BorderControl` popover
+content.
+
+Example:
+```js
+{
+	linked: 'linked-border-popover-content',
+	top: 'top-border-popover-content',
+	right: 'right-border-popover-content',
+	bottom: 'bottom-border-popover-content',
+	left: 'left-border-popover-content',
+}
+```
+
+By default, popovers are displayed relative to the button that initiated the popover. By supplying classnames for each individual popover, it is possible to add styling rules to align the popover positions to an unrelated design element, for example, the sidebar inspector in the block editor.
+
+- Required: No
+
+### `value`: `Object`
+
+An object representing the current border configuration.
+
+This may be a "flat" border where the object has `color`, `style`, and `width`
+properties or a "split" border which defines the previous properties but for
+each side; `top`, `right`, `bottom`, and `left`.
+
+Examples:
+```js
+const flatBorder = { color: '#72aee6', style: 'solid', width: '1px' };
+const splitBorders = {
+	top: { color: '#72aee6', style: 'solid', width: '1px' },
+	right: { color: '#e65054', style: 'dashed', width: '2px' },
+	bottom: { color: '#68de7c', style: 'solid', width: '1px' },
+	left: { color: '#f2d675', style: 'dotted', width: '1em' },
+};
+```
+
+- Required: No
+
+### `__experimentalHasMultipleOrigins`: `boolean`
+
+This is passed on to the color related sub-components which need to be made
+aware of whether the colors prop contains multiple origins.
+
+- Required: No
+
+### `__experimentalIsRenderedInSidebar`: `boolean`
+
+This is passed on to the color related sub-components so they may render more
+effectively when used within a sidebar.
+
+- Required: No

package/src/border-box-control/border-box-control/component.tsx

@@ -0,0 +1,123 @@
+/**
+ * WordPress dependencies
+ */
+import { __ } from '@wordpress/i18n';
+
+/**
+ * Internal dependencies
+ */
+import BorderBoxControlLinkedButton from '../border-box-control-linked-button';
+import BorderBoxControlSplitControls from '../border-box-control-split-controls';
+import { BorderControl } from '../../border-control';
+import { HStack } from '../../h-stack';
+import { StyledLabel } from '../../base-control/styles/base-control-styles';
+import { View } from '../../view';
+import { VisuallyHidden } from '../../visually-hidden';
+import { contextConnect, WordPressComponentProps } from '../../ui/context';
+import { useBorderBoxControl } from './hook';
+
+import type { BorderBoxControlProps } from '../types';
+import type { LabelProps } from '../../border-control/types';
+
+const BorderLabel = ( props: LabelProps ) => {
+	const { label, hideLabelFromVision } = props;
+
+	if ( ! label ) {
+		return null;
+	}
+
+	return hideLabelFromVision ? (
+		<VisuallyHidden as="label">{ label }</VisuallyHidden>
+	) : (
+		<StyledLabel>{ label }</StyledLabel>
+	);
+};
+
+const BorderBoxControl = (
+	props: WordPressComponentProps< BorderBoxControlProps, 'div' >,
+	forwardedRef: React.ForwardedRef< any >
+) => {
+	const {
+		className,
+		colors,
+		disableCustomColors,
+		enableAlpha,
+		enableStyle,
+		hasMixedBorders,
+		hideLabelFromVision,
+		isLinked,
+		label,
+		linkedControlClassName,
+		linkedValue,
+		onLinkedChange,
+		onSplitChange,
+		popoverClassNames,
+		splitValue,
+		toggleLinked,
+		__experimentalHasMultipleOrigins,
+		__experimentalIsRenderedInSidebar,
+		...otherProps
+	} = useBorderBoxControl( props );
+
+	return (
+		<View className={ className } { ...otherProps } ref={ forwardedRef }>
+			<BorderLabel
+				label={ label }
+				hideLabelFromVision={ hideLabelFromVision }
+			/>
+			<HStack alignment={ 'start' } expanded={ true } spacing={ 0 }>
+				{ isLinked ? (
+					<BorderControl
+						className={ linkedControlClassName }
+						colors={ colors }
+						disableCustomColors={ disableCustomColors }
+						enableAlpha={ enableAlpha }
+						enableStyle={ enableStyle }
+						onChange={ onLinkedChange }
+						placeholder={
+							hasMixedBorders ? __( 'Mixed' ) : undefined
+						}
+						popoverContentClassName={ popoverClassNames?.linked }
+						shouldSanitizeBorder={ false } // This component will handle that.
+						value={ linkedValue }
+						withSlider={ true }
+						width={ '110px' }
+						__experimentalHasMultipleOrigins={
+							__experimentalHasMultipleOrigins
+						}
+						__experimentalIsRenderedInSidebar={
+							__experimentalIsRenderedInSidebar
+						}
+					/>
+				) : (
+					<BorderBoxControlSplitControls
+						colors={ colors }
+						disableCustomColors={ disableCustomColors }
+						enableAlpha={ enableAlpha }
+						enableStyle={ enableStyle }
+						onChange={ onSplitChange }
+						popoverClassNames={ popoverClassNames }
+						value={ splitValue }
+						__experimentalHasMultipleOrigins={
+							__experimentalHasMultipleOrigins
+						}
+						__experimentalIsRenderedInSidebar={
+							__experimentalIsRenderedInSidebar
+						}
+					/>
+				) }
+				<BorderBoxControlLinkedButton
+					onClick={ toggleLinked }
+					isLinked={ isLinked }
+				/>
+			</HStack>
+		</View>
+	);
+};
+
+const ConnectedBorderBoxControl = contextConnect(
+	BorderBoxControl,
+	'BorderBoxControl'
+);
+
+export default ConnectedBorderBoxControl;

package/src/border-box-control/border-box-control/hook.ts

@@ -0,0 +1,119 @@
+/**
+ * WordPress dependencies
+ */
+import { useMemo, useState } from '@wordpress/element';
+
+/**
+ * Internal dependencies
+ */
+import * as styles from '../styles';
+import {
+	getBorderDiff,
+	getCommonBorder,
+	getSplitBorders,
+	hasMixedBorders,
+	hasSplitBorders,
+	isCompleteBorder,
+	isEmptyBorder,
+} from '../utils';
+import { useContextSystem, WordPressComponentProps } from '../../ui/context';
+import { useCx } from '../../utils/hooks/use-cx';
+
+import type { Border } from '../../border-control/types';
+import type { Borders, BorderSide, BorderBoxControlProps } from '../types';
+
+export function useBorderBoxControl(
+	props: WordPressComponentProps< BorderBoxControlProps, 'div' >
+) {
+	const { className, onChange, value, ...otherProps } = useContextSystem(
+		props,
+		'BorderBoxControl'
+	);
+
+	const mixedBorders = hasMixedBorders( value );
+	const splitBorders = hasSplitBorders( value );
+
+	const linkedValue = splitBorders
+		? getCommonBorder( value as Borders | undefined )
+		: ( value as Border );
+
+	const splitValue = splitBorders
+		? ( value as Borders )
+		: getSplitBorders( value as Border | undefined );
+
+	const [ isLinked, setIsLinked ] = useState( ! mixedBorders );
+	const toggleLinked = () => setIsLinked( ! isLinked );
+
+	const onLinkedChange = ( newBorder?: Border ) => {
+		if ( ! newBorder ) {
+			return onChange( undefined );
+		}
+
+		// If we have all props defined on the new border apply it.
+		if ( ! mixedBorders || isCompleteBorder( newBorder ) ) {
+			return onChange(
+				isEmptyBorder( newBorder ) ? undefined : newBorder
+			);
+		}
+
+		// If we had mixed borders we might have had some shared border props
+		// that we need to maintain. For example; we could have mixed borders
+		// with all the same color but different widths. Then from the linked
+		// control we change the color. We should keep the separate  widths.
+		const changes = getBorderDiff(
+			linkedValue as Border,
+			newBorder as Border
+		);
+		const updatedBorders = {
+			top: { ...( value as Borders )?.top, ...changes },
+			right: { ...( value as Borders )?.right, ...changes },
+			bottom: { ...( value as Borders )?.bottom, ...changes },
+			left: { ...( value as Borders )?.left, ...changes },
+		};
+
+		if ( hasMixedBorders( updatedBorders ) ) {
+			return onChange( updatedBorders );
+		}
+
+		const filteredResult = isEmptyBorder( updatedBorders.top )
+			? undefined
+			: updatedBorders.top;
+
+		onChange( filteredResult );
+	};
+
+	const onSplitChange = (
+		newBorder: Border | undefined,
+		side: BorderSide
+	) => {
+		const updatedBorders = { ...splitValue, [ side ]: newBorder };
+
+		if ( hasMixedBorders( updatedBorders ) ) {
+			onChange( updatedBorders );
+		} else {
+			onChange( newBorder );
+		}
+	};
+
+	const cx = useCx();
+	const classes = useMemo( () => {
+		return cx( styles.BorderBoxControl, className );
+	}, [ className ] );
+
+	const linkedControlClassName = useMemo( () => {
+		return cx( styles.LinkedBorderControl );
+	}, [] );
+
+	return {
+		...otherProps,
+		className: classes,
+		hasMixedBorders: mixedBorders,
+		isLinked,
+		linkedControlClassName,
+		onLinkedChange,
+		onSplitChange,
+		toggleLinked,
+		linkedValue,
+		splitValue,
+	};
+}

package/src/border-box-control/border-box-control/index.ts

@@ -0,0 +1,2 @@
+export { default as BorderBoxControl } from './component';
+export { useBorderBoxControl } from './hook';

package/src/border-box-control/border-box-control-linked-button/component.tsx

@@ -0,0 +1,50 @@
+/**
+ * WordPress dependencies
+ */
+import { link, linkOff } from '@wordpress/icons';
+import { __ } from '@wordpress/i18n';
+
+/**
+ * Internal dependencies
+ */
+import Button from '../../button';
+import Tooltip from '../../tooltip';
+import { View } from '../../view';
+import { contextConnect, WordPressComponentProps } from '../../ui/context';
+import { useBorderBoxControlLinkedButton } from './hook';
+
+import type { LinkedButtonProps } from '../types';
+
+const BorderBoxControlLinkedButton = (
+	props: WordPressComponentProps< LinkedButtonProps, 'div' >,
+	forwardedRef: React.ForwardedRef< any >
+) => {
+	const {
+		className,
+		isLinked,
+		...buttonProps
+	} = useBorderBoxControlLinkedButton( props );
+	const label = isLinked ? __( 'Unlink sides' ) : __( 'Link sides' );
+
+	return (
+		<Tooltip text={ label }>
+			<View className={ className }>
+				<Button
+					{ ...buttonProps }
+					variant={ isLinked ? 'primary' : 'secondary' }
+					isSmall
+					icon={ isLinked ? link : linkOff }
+					iconSize={ 16 }
+					aria-label={ label }
+					ref={ forwardedRef }
+				/>
+			</View>
+		</Tooltip>
+	);
+};
+
+const ConnectedBorderBoxControlLinkedButton = contextConnect(
+	BorderBoxControlLinkedButton,
+	'BorderBoxControlLinkedButton'
+);
+export default ConnectedBorderBoxControlLinkedButton;

package/src/border-box-control/border-box-control-linked-button/hook.ts

@@ -0,0 +1,30 @@
+/**
+ * WordPress dependencies
+ */
+import { useMemo } from '@wordpress/element';
+
+/**
+ * Internal dependencies
+ */
+import * as styles from '../styles';
+import { useContextSystem, WordPressComponentProps } from '../../ui/context';
+import { useCx } from '../../utils/hooks/use-cx';
+
+import type { LinkedButtonProps } from '../types';
+
+export function useBorderBoxControlLinkedButton(
+	props: WordPressComponentProps< LinkedButtonProps, 'div' >
+) {
+	const { className, ...otherProps } = useContextSystem(
+		props,
+		'BorderBoxControlLinkedButton'
+	);
+
+	// Generate class names.
+	const cx = useCx();
+	const classes = useMemo( () => {
+		return cx( styles.BorderBoxControlLinkedButton, className );
+	}, [ className ] );
+
+	return { ...otherProps, className: classes };
+}

package/src/border-box-control/border-box-control-linked-button/index.ts

@@ -0,0 +1 @@
+export { default } from './component';