@wordpress/components 23.6.0 → 23.8.0

package/src/custom-gradient-picker/gradient-bar/test/{utils.js → utils.ts}

@@ -5,38 +5,54 @@ import { getHorizontalRelativeGradientPosition } from '../utils';
 
 describe( 'getHorizontalRelativeGradientPosition', () => {
 	it( 'should return relative percentage position', () => {
-		const containerElement = {
-			getBoundingClientRect: () => ( {
-				x: 0,
-				width: 1000,
-			} ),
-		};
+		jest.spyOn(
+			window.HTMLElement.prototype,
+			'getBoundingClientRect'
+		).mockImplementationOnce(
+			() =>
+				( {
+					x: 0,
+					width: 1000,
+				} as DOMRect )
+		);
 
+		const containerElement = document.createElement( 'div' );
 		expect(
 			getHorizontalRelativeGradientPosition( 500, containerElement )
 		).toBe( 50 );
 	} );
 
 	it( 'should subtract the x position of the container from the mouse position', () => {
-		const containerElement = {
-			getBoundingClientRect: () => ( {
-				x: 50,
-				width: 1000,
-			} ),
-		};
+		jest.spyOn(
+			window.HTMLElement.prototype,
+			'getBoundingClientRect'
+		).mockImplementationOnce(
+			() =>
+				( {
+					x: 50,
+					width: 1000,
+				} as DOMRect )
+		);
 
+		const containerElement = document.createElement( 'div' );
 		expect(
 			getHorizontalRelativeGradientPosition( 550, containerElement )
 		).toBe( 50 );
 	} );
 
 	it( 'should clamp to a whole percentage number', () => {
-		const containerElement = {
-			getBoundingClientRect: () => ( {
-				x: 0,
-				width: 1000,
-			} ),
-		};
+		jest.spyOn(
+			window.HTMLElement.prototype,
+			'getBoundingClientRect'
+		).mockImplementationOnce(
+			() =>
+				( {
+					x: 0,
+					width: 1000,
+				} as DOMRect )
+		);
+
+		const containerElement = document.createElement( 'div' );
 
 		expect(
 			getHorizontalRelativeGradientPosition( 333, containerElement )
@@ -44,12 +60,17 @@ describe( 'getHorizontalRelativeGradientPosition', () => {
 	} );
 
 	it( 'should clamp to zero when mouse position is less the x position', () => {
-		const containerElement = {
-			getBoundingClientRect: () => ( {
-				x: 50,
-				width: 1000,
-			} ),
-		};
+		jest.spyOn(
+			window.HTMLElement.prototype,
+			'getBoundingClientRect'
+		).mockImplementationOnce(
+			() =>
+				( {
+					x: 50,
+					width: 1000,
+				} as DOMRect )
+		);
+		const containerElement = document.createElement( 'div' );
 
 		expect(
 			getHorizontalRelativeGradientPosition( 2, containerElement )
@@ -57,12 +78,18 @@ describe( 'getHorizontalRelativeGradientPosition', () => {
 	} );
 
 	it( 'should clamp to 100 when mouse position is greater than width', () => {
-		const containerElement = {
-			getBoundingClientRect: () => ( {
-				x: 0,
-				width: 1000,
-			} ),
-		};
+		jest.spyOn(
+			window.HTMLElement.prototype,
+			'getBoundingClientRect'
+		).mockImplementationOnce(
+			() =>
+				( {
+					x: 50,
+					width: 1000,
+				} as DOMRect )
+		);
+
+		const containerElement = document.createElement( 'div' );
 
 		expect(
 			getHorizontalRelativeGradientPosition( 1500, containerElement )
@@ -70,7 +97,7 @@ describe( 'getHorizontalRelativeGradientPosition', () => {
 	} );
 
 	it( 'should return undefined if no containerElement is provided', () => {
-		const containerElement = undefined;
+		const containerElement = null;
 
 		expect(
 			getHorizontalRelativeGradientPosition( 1500, containerElement )

package/src/custom-gradient-picker/gradient-bar/utils.ts

@@ -0,0 +1,193 @@
+/**
+ * Internal dependencies
+ */
+import { MINIMUM_DISTANCE_BETWEEN_POINTS } from './constants';
+import type { ControlPoint } from '../types';
+
+/**
+ * Clamps a number between 0 and 100.
+ *
+ * @param value Value to clamp.
+ *
+ * @return Value clamped between 0 and 100.
+ */
+export function clampPercent( value: number ) {
+	return Math.max( 0, Math.min( 100, value ) );
+}
+
+/**
+ * Check if a control point is overlapping with another.
+ *
+ * @param value        Array of control points.
+ * @param initialIndex Index of the position to test.
+ * @param newPosition  New position of the control point.
+ * @param minDistance  Distance considered to be overlapping.
+ *
+ * @return True if the point is overlapping.
+ */
+export function isOverlapping(
+	value: ControlPoint[],
+	initialIndex: number,
+	newPosition: number,
+	minDistance: number = MINIMUM_DISTANCE_BETWEEN_POINTS
+) {
+	const initialPosition = value[ initialIndex ].position;
+	const minPosition = Math.min( initialPosition, newPosition );
+	const maxPosition = Math.max( initialPosition, newPosition );
+
+	return value.some( ( { position }, index ) => {
+		return (
+			index !== initialIndex &&
+			( Math.abs( position - newPosition ) < minDistance ||
+				( minPosition < position && position < maxPosition ) )
+		);
+	} );
+}
+
+/**
+ * Adds a control point from an array and returns the new array.
+ *
+ * @param points   Array of control points.
+ * @param position Position to insert the new point.
+ * @param color    Color to update the control point at index.
+ *
+ * @return New array of control points.
+ */
+export function addControlPoint(
+	points: ControlPoint[],
+	position: number,
+	color: ControlPoint[ 'color' ]
+) {
+	const nextIndex = points.findIndex(
+		( point ) => point.position > position
+	);
+	const newPoint = { color, position };
+	const newPoints = points.slice();
+	newPoints.splice( nextIndex - 1, 0, newPoint );
+	return newPoints;
+}
+
+/**
+ * Removes a control point from an array and returns the new array.
+ *
+ * @param points Array of control points.
+ * @param index  Index to remove.
+ *
+ * @return New array of control points.
+ */
+export function removeControlPoint( points: ControlPoint[], index: number ) {
+	return points.filter( ( _point, pointIndex ) => {
+		return pointIndex !== index;
+	} );
+}
+/**
+ * Updates a control point from an array and returns the new array.
+ *
+ * @param points   Array of control points.
+ * @param index    Index to update.
+ * @param newPoint New control point to replace the index.
+ *
+ * @return New array of control points.
+ */
+export function updateControlPoint(
+	points: ControlPoint[],
+	index: number,
+	newPoint: ControlPoint
+) {
+	const newValue = points.slice();
+	newValue[ index ] = newPoint;
+	return newValue;
+}
+
+/**
+ * Updates the position of a control point from an array and returns the new array.
+ *
+ * @param points      Array of control points.
+ * @param index       Index to update.
+ * @param newPosition Position to move the control point at index.
+ *
+ * @return New array of control points.
+ */
+export function updateControlPointPosition(
+	points: ControlPoint[],
+	index: number,
+	newPosition: ControlPoint[ 'position' ]
+) {
+	if ( isOverlapping( points, index, newPosition ) ) {
+		return points;
+	}
+	const newPoint = {
+		...points[ index ],
+		position: newPosition,
+	};
+	return updateControlPoint( points, index, newPoint );
+}
+
+/**
+ * Updates the position of a control point from an array and returns the new array.
+ *
+ * @param points   Array of control points.
+ * @param index    Index to update.
+ * @param newColor Color to update the control point at index.
+ *
+ * @return New array of control points.
+ */
+export function updateControlPointColor(
+	points: ControlPoint[],
+	index: number,
+	newColor: ControlPoint[ 'color' ]
+) {
+	const newPoint = {
+		...points[ index ],
+		color: newColor,
+	};
+	return updateControlPoint( points, index, newPoint );
+}
+
+/**
+ * Updates the position of a control point from an array and returns the new array.
+ *
+ * @param points   Array of control points.
+ * @param position Position of the color stop.
+ * @param newColor Color to update the control point at index.
+ *
+ * @return New array of control points.
+ */
+export function updateControlPointColorByPosition(
+	points: ControlPoint[],
+	position: ControlPoint[ 'position' ],
+	newColor: ControlPoint[ 'color' ]
+) {
+	const index = points.findIndex( ( point ) => point.position === position );
+	return updateControlPointColor( points, index, newColor );
+}
+
+/**
+ * Gets the horizontal coordinate when dragging a control point with the mouse.
+ *
+ * @param mouseXcoordinate Horizontal coordinate of the mouse position.
+ * @param containerElement Container for the gradient picker.
+ *
+ * @return Whole number percentage from the left.
+ */
+export function getHorizontalRelativeGradientPosition(
+	mouseXcoordinate: number,
+	containerElement: HTMLDivElement
+): number;
+export function getHorizontalRelativeGradientPosition(
+	mouseXcoordinate: number,
+	containerElement: null
+): undefined;
+export function getHorizontalRelativeGradientPosition(
+	mouseXCoordinate: number,
+	containerElement: HTMLDivElement | null
+) {
+	if ( ! containerElement ) {
+		return;
+	}
+	const { x, width } = containerElement.getBoundingClientRect();
+	const absolutePositionValue = mouseXCoordinate - x;
+	return Math.round(
+		clampPercent( ( absolutePositionValue * 100 ) / width )
+	);
+}

package/src/custom-gradient-picker/{index.js → index.tsx}

@@ -1,9 +1,8 @@
-// @ts-nocheck
-
 /**
  * External dependencies
  */
 import classnames from 'classnames';
+import type gradientParser from 'gradient-parser';
 
 /**
  * WordPress dependencies
@@ -30,23 +29,31 @@ import {
 	DEFAULT_LINEAR_GRADIENT_ANGLE,
 	HORIZONTAL_GRADIENT_ORIENTATION,
 	GRADIENT_OPTIONS,
-	DEFAULT_GRADIENT,
 } from './constants';
 import {
 	AccessoryWrapper,
 	SelectWrapper,
 } from './styles/custom-gradient-picker-styles';
+import type {
+	CustomGradientPickerProps,
+	GradientAnglePickerProps,
+	GradientTypePickerProps,
+} from './types';
 
-const GradientAnglePicker = ( { gradientAST, hasGradient, onChange } ) => {
+const GradientAnglePicker = ( {
+	gradientAST,
+	hasGradient,
+	onChange,
+}: GradientAnglePickerProps ) => {
 	const angle =
 		gradientAST?.orientation?.value ?? DEFAULT_LINEAR_GRADIENT_ANGLE;
-	const onAngleChange = ( newAngle ) => {
+	const onAngleChange = ( newAngle: number ) => {
 		onChange(
 			serializeGradient( {
 				...gradientAST,
 				orientation: {
 					type: 'angular',
-					value: newAngle,
+					value: `${ newAngle }`,
 				},
 			} )
 		);
@@ -60,17 +67,22 @@ const GradientAnglePicker = ( { gradientAST, hasGradient, onChange } ) => {
 	);
 };
 
-const GradientTypePicker = ( { gradientAST, hasGradient, onChange } ) => {
+const GradientTypePicker = ( {
+	gradientAST,
+	hasGradient,
+	onChange,
+}: GradientTypePickerProps ) => {
 	const { type } = gradientAST;
+
 	const onSetLinearGradient = () => {
 		onChange(
 			serializeGradient( {
 				...gradientAST,
-				...( gradientAST.orientation
-					? {}
-					: { orientation: HORIZONTAL_GRADIENT_ORIENTATION } ),
+				orientation: gradientAST.orientation
+					? undefined
+					: HORIZONTAL_GRADIENT_ORIENTATION,
 				type: 'linear-gradient',
-			} )
+			} as gradientParser.LinearGradientNode )
 		);
 	};
 
@@ -84,7 +96,7 @@ const GradientTypePicker = ( { gradientAST, hasGradient, onChange } ) => {
 		);
 	};
 
-	const handleOnChange = ( next ) => {
+	const handleOnChange = ( next: string ) => {
 		if ( next === 'linear-gradient' ) {
 			onSetLinearGradient();
 		}
@@ -102,30 +114,57 @@ const GradientTypePicker = ( { gradientAST, hasGradient, onChange } ) => {
 			onChange={ handleOnChange }
 			options={ GRADIENT_OPTIONS }
 			size="__unstable-large"
-			value={ hasGradient && type }
+			value={ hasGradient ? type : undefined }
 		/>
 	);
 };
 
-export default function CustomGradientPicker( {
+/**
+ * CustomGradientPicker is a React component that renders a UI for specifying
+ * linear or radial gradients. Radial gradients are displayed in the picker as
+ * a slice of the gradient from the center to the outside.
+ *
+ * ```jsx
+ * import { CustomGradientPicker } from '@wordpress/components';
+ * import { useState } from '@wordpress/element';
+ *
+ * const MyCustomGradientPicker = () => {
+ *   const [ gradient, setGradient ] = useState();
+ *
+ *   return (
+ *     <CustomGradientPicker
+ *			value={ gradient }
+ *			onChange={ setGradient }
+ *     />
+ *   );
+ * };
+ * ```
+ */
+export function CustomGradientPicker( {
 	/** Start opting into the new margin-free styles that will become the default in a future version. */
 	__nextHasNoMargin = false,
 	value,
 	onChange,
-	__experimentalIsRenderedInSidebar,
-} ) {
-	const gradientAST = getGradientAstWithDefault( value );
+	__experimentalIsRenderedInSidebar = false,
+}: CustomGradientPickerProps ) {
+	const { gradientAST, hasGradient } = getGradientAstWithDefault( value );
+
 	// On radial gradients the bar should display a linear gradient.
 	// On radial gradients the bar represents a slice of the gradient from the center until the outside.
 	// On liner gradients the bar represents the color stops from left to right independently of the angle.
 	const background = getLinearGradientRepresentation( gradientAST );
-	const hasGradient = gradientAST.value !== DEFAULT_GRADIENT;
+
 	// Control points color option may be hex from presets, custom colors will be rgb.
 	// The position should always be a percentage.
-	const controlPoints = gradientAST.colorStops.map( ( colorStop ) => ( {
-		color: getStopCssColor( colorStop ),
-		position: parseInt( colorStop.length.value ),
-	} ) );
+	const controlPoints = gradientAST.colorStops.map( ( colorStop ) => {
+		return {
+			color: getStopCssColor( colorStop ),
+			// Although it's already been checked by `hasUnsupportedLength` in `getGradientAstWithDefault`,
+			// TypeScript doesn't know that `colorStop.length` is not undefined here.
+			// @ts-expect-error
+			position: parseInt( colorStop.length.value ),
+		};
+	} );
 
 	if ( ! __nextHasNoMargin ) {
 		deprecated(
@@ -187,3 +226,5 @@ export default function CustomGradientPicker( {
 		</VStack>
 	);
 }
+
+export default CustomGradientPicker;

package/src/custom-gradient-picker/serializer.ts

@@ -0,0 +1,78 @@
+/**
+ * External dependencies
+ */
+import type gradientParser from 'gradient-parser';
+
+export function serializeGradientColor( {
+	type,
+	value,
+}: gradientParser.ColorStop ) {
+	if ( type === 'literal' ) {
+		return value;
+	}
+	if ( type === 'hex' ) {
+		return `#${ value }`;
+	}
+	return `${ type }(${ value.join( ',' ) })`;
+}
+
+export function serializeGradientPosition(
+	position: gradientParser.ColorStop[ 'length' ]
+) {
+	if ( ! position ) {
+		return '';
+	}
+	const { value, type } = position;
+	return `${ value }${ type }`;
+}
+
+export function serializeGradientColorStop( {
+	type,
+	value,
+	length,
+}: gradientParser.ColorStop ) {
+	return `${ serializeGradientColor( {
+		type,
+		value,
+	} as gradientParser.ColorStop ) } ${ serializeGradientPosition( length ) }`;
+}
+
+export function serializeGradientOrientation(
+	orientation: gradientParser.GradientNode[ 'orientation' ]
+) {
+	if (
+		Array.isArray( orientation ) ||
+		! orientation ||
+		orientation.type !== 'angular'
+	) {
+		return;
+	}
+	return `${ orientation.value }deg`;
+}
+
+export function serializeGradient( {
+	type,
+	orientation,
+	colorStops,
+}: gradientParser.GradientNode ) {
+	const serializedOrientation = serializeGradientOrientation( orientation );
+	const serializedColorStops = colorStops
+		.sort( ( colorStop1, colorStop2 ) => {
+			const getNumericStopValue = (
+				colorStop: gradientParser.ColorStop
+			) => {
+				return colorStop?.length?.value === undefined
+					? 0
+					: parseInt( colorStop.length.value );
+			};
+
+			return (
+				getNumericStopValue( colorStop1 ) -
+				getNumericStopValue( colorStop2 )
+			);
+		} )
+		.map( serializeGradientColorStop );
+	return `${ type }(${ [ serializedOrientation, ...serializedColorStops ]
+		.filter( Boolean )
+		.join( ',' ) })`;
+}

package/src/custom-gradient-picker/stories/index.tsx

@@ -0,0 +1,45 @@
+/**
+ * External dependencies
+ */
+import type { ComponentMeta, ComponentStory } from '@storybook/react';
+/**
+ * WordPress dependencies
+ */
+import { useState } from '@wordpress/element';
+
+/**
+ * Internal dependencies
+ */
+import CustomGradientPicker from '../';
+
+const meta: ComponentMeta< typeof CustomGradientPicker > = {
+	title: 'Components/CustomGradientPicker',
+	component: CustomGradientPicker,
+	parameters: {
+		actions: { argTypesRegex: '^on.*' },
+		controls: { expanded: true },
+		docs: { source: { state: 'open' } },
+	},
+};
+export default meta;
+
+const CustomGradientPickerWithState: ComponentStory<
+	typeof CustomGradientPicker
+> = ( { onChange, ...props } ) => {
+	const [ gradient, setGradient ] = useState< string >();
+	return (
+		<CustomGradientPicker
+			{ ...props }
+			value={ gradient }
+			onChange={ ( newGradient ) => {
+				setGradient( newGradient );
+				onChange( newGradient );
+			} }
+		/>
+	);
+};
+
+export const Default = CustomGradientPickerWithState.bind( {} );
+Default.args = {
+	__nextHasNoMargin: true,
+};

package/src/custom-gradient-picker/style.scss

@@ -7,14 +7,30 @@ $components-custom-gradient-picker__padding: $grid-unit-20; // 48px container, 1
 	}
 }
 
-.components-custom-gradient-picker__gradient-bar:not(.has-gradient) {
-	opacity: 0.4;
-}
-
 .components-custom-gradient-picker__gradient-bar {
 	border-radius: $radius-block-ui;
 	width: 100%;
 	height: $grid-unit-60;
+	position: relative;
+	z-index: 1;
+
+	&.has-gradient {
+		// The background image creates a checkerboard pattern. Ignore rtlcss to
+		// make it work both in LTR and RTL.
+		// See https://github.com/WordPress/gutenberg/pull/42510
+		/*rtl:begin:ignore*/
+		background-image:
+			repeating-linear-gradient(45deg, $gray-200 25%, transparent 25%, transparent 75%, $gray-200 75%, $gray-200),
+			repeating-linear-gradient(45deg, $gray-200 25%, transparent 25%, transparent 75%, $gray-200 75%, $gray-200);
+		background-position: 0 0, 12px 12px;
+		/*rtl:end:ignore*/
+		background-size: calc(2 * 12px) calc(2 * 12px);
+	}
+
+	.components-custom-gradient-picker__gradient-bar-background {
+		position: absolute;
+		inset: 0;
+	}
 
 	.components-custom-gradient-picker__markers-container {
 		position: relative;
@@ -109,3 +125,8 @@ $components-custom-gradient-picker__padding: $grid-unit-20; // 48px container, 1
 		}
 	}
 }
+
+.components-custom-gradient-picker__ui-line {
+	position: relative;
+	z-index: 0;
+}