@wordpress/block-editor 15.6.0 → 15.6.1

package/src/hooks/test/metadata.js

@@ -0,0 +1,316 @@
+/**
+ * WordPress dependencies
+ */
+import {
+	getBlockTypes,
+	registerBlockType,
+	unregisterBlockType,
+} from '@wordpress/blocks';
+
+/**
+ * Internal dependencies
+ */
+import { addTransforms } from '../metadata';
+
+describe( 'metadata', () => {
+	afterEach( () => {
+		getBlockTypes().forEach( ( block ) => {
+			unregisterBlockType( block.name );
+		} );
+	} );
+
+	describe( 'addTransforms()', () => {
+		it( 'should not preserve metadata in wrapping transforms', () => {
+			const source = [
+				{
+					name: 'core/foo',
+					attributes: { metadata: { noteId: 1 } },
+					innerBlocks: [],
+				},
+				{
+					name: 'core/foo',
+					attributes: { metadata: { noteId: 2 } },
+					innerBlocks: [],
+				},
+			];
+			const result = {
+				name: 'core/bar',
+				attributes: {},
+				innerBlocks: source,
+			};
+			const transformed = addTransforms( result, source, 0, [ result ] );
+
+			expect( transformed.attributes.metadata ).toBeUndefined();
+		} );
+
+		it( 'should not preserve metadata in one-to-many transforms', () => {
+			const source = [
+				{
+					name: 'core/foo',
+					attributes: { metadata: { noteId: 1 } },
+					innerBlocks: [],
+				},
+			];
+			const results = [
+				{
+					name: 'core/bar',
+					attributes: {},
+					innerBlocks: [],
+				},
+				{
+					name: 'core/bar',
+					attributes: {},
+					innerBlocks: [],
+				},
+			];
+			const transformed = addTransforms(
+				results[ 0 ],
+				source,
+				0,
+				results
+			);
+
+			expect( transformed.attributes.metadata ).toBeUndefined();
+		} );
+
+		it( 'should not preserve metadata in many-to-one transforms', () => {
+			const source = [
+				{
+					name: 'core/foo',
+					attributes: { metadata: { noteId: 1 } },
+					innerBlocks: [],
+				},
+				{
+					name: 'core/foo',
+					attributes: { metadata: { noteId: 2 } },
+					innerBlocks: [],
+				},
+			];
+			const result = {
+				name: 'core/bar',
+				attributes: {},
+				innerBlocks: [],
+			};
+			const transformed = addTransforms( result, source, 0, [ result ] );
+
+			expect( transformed.attributes.metadata ).toBeUndefined();
+		} );
+
+		it( 'should not preserve metadata in many-to-many transforms with different counts', () => {
+			const source = [
+				{
+					name: 'core/foo',
+					attributes: { metadata: { noteId: 1 } },
+					innerBlocks: [],
+				},
+				{
+					name: 'core/foo',
+					attributes: { metadata: { noteId: 2 } },
+					innerBlocks: [],
+				},
+				{
+					name: 'core/foo',
+					attributes: { metadata: { noteId: 3 } },
+					innerBlocks: [],
+				},
+			];
+			const results = [
+				{
+					name: 'core/bar',
+					attributes: {},
+					innerBlocks: [],
+				},
+				{
+					name: 'core/bar',
+					attributes: {},
+					innerBlocks: [],
+				},
+			];
+			const [ firstTransformed, secondTransformed ] = results.map(
+				( result, index ) =>
+					addTransforms( result, source, index, results )
+			);
+
+			expect( firstTransformed.attributes.metadata ).toBeUndefined();
+			expect( secondTransformed.attributes.metadata ).toBeUndefined();
+		} );
+
+		it( 'should preserve metadata in many-to-many transforms with same counts', () => {
+			const source = [
+				{
+					name: 'core/foo',
+					attributes: { metadata: { noteId: 1 } },
+					innerBlocks: [],
+				},
+				{
+					name: 'core/foo',
+					attributes: { metadata: { noteId: 2 } },
+					innerBlocks: [],
+				},
+			];
+			const results = [
+				{
+					name: 'core/bar',
+					attributes: { metadata: { noteId: 1 } },
+				},
+				{
+					name: 'core/bar',
+					attributes: { metadata: { noteId: 2 } },
+				},
+			];
+
+			const [ firstTransformed, secondTransformed ] = results.map(
+				( result, index ) =>
+					addTransforms( result, source, index, results )
+			);
+
+			expect( firstTransformed.attributes.metadata ).toEqual( {
+				noteId: 1,
+			} );
+			expect( secondTransformed.attributes.metadata ).toEqual( {
+				noteId: 2,
+			} );
+		} );
+
+		it( 'should preserve custom name metadata', () => {
+			registerBlockType( 'core/bar', {
+				title: 'Bar',
+			} );
+			const source = [
+				{
+					name: 'core/foo',
+					attributes: {
+						metadata: { name: 'Custom Name' },
+					},
+					innerBlocks: [],
+				},
+			];
+			const result = {
+				name: 'core/bar',
+				attributes: {},
+				innerBlocks: [],
+			};
+			const transformed = addTransforms( result, source, 0, [ result ] );
+
+			expect( transformed.attributes.metadata.name ).toBe(
+				'Custom Name'
+			);
+		} );
+
+		it( 'should not preserve custom name metadata when target block does not support renaming', () => {
+			registerBlockType( 'core/bar', {
+				title: 'Bar',
+				supports: {
+					renaming: false,
+				},
+			} );
+
+			const source = [
+				{
+					name: 'core/foo',
+					attributes: {
+						metadata: { name: 'Custom Name' },
+					},
+					innerBlocks: [],
+				},
+			];
+			const result = {
+				name: 'core/bar',
+				attributes: {},
+				innerBlocks: [],
+			};
+			const transformed = addTransforms( result, source, 0, [ result ] );
+
+			expect( transformed.attributes.metadata?.name ).toBeUndefined();
+		} );
+
+		it( 'should preserve block visibility metadata', () => {
+			registerBlockType( 'core/bar', {
+				title: 'Bar',
+			} );
+
+			const source = [
+				{
+					name: 'core/foo',
+					attributes: {
+						metadata: { blockVisibility: false },
+					},
+					innerBlocks: [],
+				},
+			];
+			const result = {
+				name: 'core/bar',
+				attributes: {},
+				innerBlocks: [],
+			};
+			const transformed = addTransforms( result, source, 0, [ result ] );
+
+			expect( transformed.attributes.metadata?.blockVisibility ).toBe(
+				false
+			);
+		} );
+
+		it( 'should not preserve block visibility metadata when target block does not support it', () => {
+			registerBlockType( 'core/bar', {
+				title: 'Bar',
+				supports: {
+					blockVisibility: false,
+				},
+			} );
+
+			const source = [
+				{
+					name: 'core/foo',
+					attributes: {
+						metadata: { blockVisibility: false },
+					},
+					innerBlocks: [],
+				},
+			];
+			const result = {
+				name: 'core/bar',
+				attributes: {},
+				innerBlocks: [],
+			};
+			const transformed = addTransforms( result, source, 0, [ result ] );
+
+			expect(
+				transformed.attributes.metadata?.blockVisibility
+			).toBeUndefined();
+		} );
+
+		it( 'should not override existing metadata in target block', () => {
+			const source = [
+				{
+					name: 'core/foo',
+					attributes: {
+						metadata: {
+							noteId: 1,
+							name: 'Custom Name',
+							blockVisibility: false,
+						},
+					},
+					innerBlocks: [],
+				},
+			];
+			const result = {
+				name: 'core/bar',
+				attributes: {
+					metadata: {
+						noteId: 2,
+						name: 'Existing Name',
+						blockVisibility: true,
+					},
+				},
+				innerBlocks: [],
+			};
+			const transformed = addTransforms( result, source, 0, [ result ] );
+
+			expect( transformed.attributes.metadata ).toEqual( {
+				noteId: 2,
+				name: 'Existing Name',
+				blockVisibility: true,
+			} );
+		} );
+	} );
+} );

package/src/hooks/typography.js

@@ -116,11 +116,13 @@ function TypographyInspectorControl( { children, resetAllFilter } ) {
 
 export function TypographyPanel( { clientId, name, setAttributes, settings } ) {
 	function selector( select ) {
-		const { style, fontFamily, fontSize } =
+		const { style, fontFamily, fontSize, fitText } =
 			select( blockEditorStore ).getBlockAttributes( clientId ) || {};
-		return { style, fontFamily, fontSize };
+		return { style, fontFamily, fontSize, fitText };
 	}
-	const { style, fontFamily, fontSize } = useSelect( selector, [ clientId ] );
+	const { style, fontFamily, fontSize, fitText } = useSelect( selector, [
+		clientId,
+	] );
 	const isEnabled = useHasTypographyPanel( settings );
 	const value = useMemo(
 		() => attributesToStyle( { style, fontFamily, fontSize } ),
@@ -128,7 +130,16 @@ export function TypographyPanel( { clientId, name, setAttributes, settings } ) {
 	);
 
 	const onChange = ( newStyle ) => {
-		setAttributes( styleToAttributes( newStyle ) );
+		const newAttributes = styleToAttributes( newStyle );
+
+		// If setting a font size and fitText is currently enabled, disable it
+		const hasFontSize =
+			newAttributes.fontSize || newAttributes.style?.typography?.fontSize;
+		if ( hasFontSize && fitText ) {
+			newAttributes.fitText = undefined;
+		}
+
+		setAttributes( newAttributes );
 	};
 
 	if ( ! isEnabled ) {

package/src/store/private-selectors.js

@@ -95,7 +95,7 @@ export const isBlockSubtreeDisabled = ( state, clientId ) => {
  * @param {string} rootClientId The client ID of the root container block.
  * @return {boolean} Whether the container allows insertion.
  */
-export function isContainerInsertableToInWriteMode(
+export function isContainerInsertableToInContentOnlyMode(
 	state,
 	blockName,
 	rootClientId
@@ -105,7 +105,7 @@ export function isContainerInsertableToInWriteMode(
 	const isContainerContentBlock = isContentBlock( rootBlockName );
 	const isRootBlockMain = getSectionRootClientId( state ) === rootClientId;
 
-	// In write mode, containers shouldn't be inserted into unless:
+	// In contentOnly mode, containers shouldn't be inserted into unless:
 	// 1. they are a section root;
 	// 2. they are a content block and the block to be inserted is also content.
 	return (

package/src/store/selectors.js

@@ -43,7 +43,7 @@ import {
 	isSectionBlock,
 	getParentSectionBlock,
 	isZoomOut,
-	isContainerInsertableToInWriteMode,
+	isContainerInsertableToInContentOnlyMode,
 } from './private-selectors';
 
 const { isContentBlock } = unlock( blocksPrivateApis );
@@ -1682,15 +1682,7 @@ const canInsertBlockTypeUnmemoized = (
 		blockType = getBlockType( blockName );
 	}
 
-	const isLocked = !! getTemplateLock( state, rootClientId );
-	if ( isLocked ) {
-		return false;
-	}
-	const isContentRoleBlock = isContentBlock( blockName );
-	const isParentSectionBlock = !! isSectionBlock( state, rootClientId );
-	// It shouldn't be possible to insert inside a section block unless in
-	// some cases when the block is a content block.
-	if ( isParentSectionBlock && ! isContentRoleBlock ) {
+	if ( getTemplateLock( state, rootClientId ) ) {
 		return false;
 	}
 
@@ -1707,10 +1699,29 @@ const canInsertBlockTypeUnmemoized = (
 		return false;
 	}
 
-	// In write mode, check if this container allows insertion.
+	// It shouldn't be possible to insert inside a section block unless in
+	// some cases when the block is a content block.
+	const isContentRoleBlock = isContentBlock( blockName );
+	const isParentSectionBlock = !! isSectionBlock( state, rootClientId );
+	const isBlockWithinSection = !! getParentSectionBlock(
+		state,
+		rootClientId
+	);
+	if (
+		( isParentSectionBlock || isBlockWithinSection ) &&
+		! isContentRoleBlock
+	) {
+		return false;
+	}
+
+	// In content only mode, check if this container allows insertion.
 	if (
-		blockEditingMode === 'contentOnly' &&
-		! isContainerInsertableToInWriteMode( state, blockName, rootClientId )
+		( isParentSectionBlock || blockEditingMode === 'contentOnly' ) &&
+		! isContainerInsertableToInContentOnlyMode(
+			state,
+			blockName,
+			rootClientId
+		)
 	) {
 		return false;
 	}
@@ -1858,6 +1869,8 @@ export function canRemoveBlock( state, clientId ) {
 		return false;
 	}
 
+	// It shouldn't be possible to move in a section block unless in
+	// some cases when the block is a content block.
 	const isBlockWithinSection = !! getParentSectionBlock( state, clientId );
 	const isContentRoleBlock = isContentBlock(
 		getBlockName( state, clientId )
@@ -1866,21 +1879,21 @@ export function canRemoveBlock( state, clientId ) {
 		return false;
 	}
 
-	const blockEditingMode = getBlockEditingMode( state, rootClientId );
-
-	// Check if the parent container allows insertion/removal in write mode
+	const isParentSectionBlock = !! isSectionBlock( state, rootClientId );
+	const rootBlockEditingMode = getBlockEditingMode( state, rootClientId );
+	// Check if the parent container allows insertion/removal in contentOnly mode
 	if (
-		blockEditingMode === 'contentOnly' &&
-		! isContainerInsertableToInWriteMode(
+		( isParentSectionBlock || rootBlockEditingMode === 'contentOnly' ) &&
+		! isContainerInsertableToInContentOnlyMode(
 			state,
-			getBlockName( state, rootClientId ),
+			getBlockName( state, clientId ),
 			rootClientId
 		)
 	) {
 		return false;
 	}
 
-	return blockEditingMode !== 'disabled';
+	return rootBlockEditingMode !== 'disabled';
 }
 
 /**
@@ -1913,9 +1926,34 @@ export function canMoveBlock( state, clientId ) {
 	}
 
 	const rootClientId = getBlockRootClientId( state, clientId );
-	if ( getTemplateLock( state, rootClientId ) === 'all' ) {
+	const templateLock = getTemplateLock( state, rootClientId );
+	if ( templateLock === 'all' || templateLock === 'contentOnly' ) {
+		return false;
+	}
+
+	const isBlockWithinSection = !! getParentSectionBlock( state, clientId );
+	const isContentRoleBlock = isContentBlock(
+		getBlockName( state, clientId )
+	);
+	if ( isBlockWithinSection && ! isContentRoleBlock ) {
 		return false;
 	}
+
+	// If the parent is a section or is `contentOnly`, then check is the inner block
+	// should be allowed to move.
+	const isParentSectionBlock = !! isSectionBlock( state, rootClientId );
+	const rootBlockEditingMode = getBlockEditingMode( state, rootClientId );
+	if (
+		( isParentSectionBlock || rootBlockEditingMode === 'contentOnly' ) &&
+		! isContainerInsertableToInContentOnlyMode(
+			state,
+			getBlockName( state, clientId ),
+			rootClientId
+		)
+	) {
+		return false;
+	}
+
 	return getBlockEditingMode( state, rootClientId ) !== 'disabled';
 }
 

package/src/store/test/selectors.js

@@ -3081,7 +3081,7 @@ describe( 'selectors', () => {
 					byClientId: new Map(
 						Object.entries( {
 							block1: { name: 'core/test-block-ancestor' },
-							block2: { name: 'core/block' },
+							block2: { name: 'core/group' },
 							block3: { name: 'core/test-block-parent' },
 						} )
 					),

package/src/store/utils.js

@@ -10,7 +10,7 @@ import { parse as grammarParse } from '@wordpress/block-serialization-default-pa
 import { selectBlockPatternsKey } from './private-keys';
 import { unlock } from '../lock-unlock';
 import { STORE_NAME } from './constants';
-import { getSectionRootClientId } from './private-selectors';
+import { getSectionRootClientId, isSectionBlock } from './private-selectors';
 import { getBlockEditingMode } from './selectors';
 import { INSERTER_PATTERN_TYPES } from '../components/inserter/block-patterns-tab/utils';
 
@@ -140,5 +140,6 @@ export const getInsertBlockTypeDependants = () => ( state, rootClientId ) => {
 		state.settings.templateLock,
 		getBlockEditingMode( state, rootClientId ),
 		getSectionRootClientId( state ),
+		isSectionBlock( state, rootClientId ),
 	];
 };

package/src/utils/fit-text-utils.js

@@ -20,18 +20,13 @@ function generateCSSRule( elementSelector, fontSize ) {
  * @param {HTMLElement} textElement     The text element
  * @param {string}      elementSelector CSS selector for the text element
  * @param {Function}    applyStylesFn   Function to apply test styles
- * @param {number}      maxSize         Maximum font size in pixels (default: 600)
  * @return {number} Optimal font size
  */
-function findOptimalFontSize(
-	textElement,
-	elementSelector,
-	applyStylesFn,
-	maxSize = 600
-) {
+function findOptimalFontSize( textElement, elementSelector, applyStylesFn ) {
 	const alreadyHasScrollableHeight =
 		textElement.scrollHeight > textElement.clientHeight;
 	let minSize = 5;
+	let maxSize = 600;
 	let bestSize = minSize;
 
 	while ( minSize <= maxSize ) {
@@ -61,14 +56,8 @@ function findOptimalFontSize(
  * @param {HTMLElement} textElement     The text element (paragraph, heading, etc.)
  * @param {string}      elementSelector CSS selector for the text element
  * @param {Function}    applyStylesFn   Function to apply CSS styles (pass empty string to clear)
- * @param {number}      maxSize         Maximum font size in pixels.
  */
-export function optimizeFitText(
-	textElement,
-	elementSelector,
-	applyStylesFn,
-	maxSize
-) {
+export function optimizeFitText( textElement, elementSelector, applyStylesFn ) {
 	if ( ! textElement ) {
 		return;
 	}
@@ -78,8 +67,7 @@ export function optimizeFitText(
 	const optimalSize = findOptimalFontSize(
 		textElement,
 		elementSelector,
-		applyStylesFn,
-		maxSize
+		applyStylesFn
 	);
 
 	const cssRule = generateCSSRule( elementSelector, optimalSize );