@wordpress/block-editor 15.6.1-next.36001005c.0 → 15.6.2

package/src/hooks/metadata.js

@@ -2,6 +2,8 @@
  * WordPress dependencies
  */
 import { addFilter } from '@wordpress/hooks';
+import { hasBlockSupport } from '@wordpress/blocks';
+
 const META_ATTRIBUTE_NAME = 'metadata';
 
 /**
@@ -28,8 +30,95 @@ export function addMetaAttribute( blockTypeSettings ) {
 	return blockTypeSettings;
 }
 
+/**
+ * Add metadata transforms.
+ *
+ * @param {Object} result  The transformed block.
+ * @param {Array}  source  Original blocks transformed.
+ * @param {number} index   Index of the transformed block.
+ * @param {Array}  results All blocks that resulted from the transformation.
+ * @return {Object} Modified transformed block.
+ */
+export function addTransforms( result, source, index, results ) {
+	// If the condition verifies we are probably in the presence of a wrapping transform
+	// e.g: nesting paragraphs in a group or columns and in that case the metadata should not be kept.
+	if ( results.length === 1 && result.innerBlocks.length === source.length ) {
+		return result;
+	}
+
+	// If we are transforming one block to multiple blocks or multiple blocks to one block,
+	// we ignore the metadata during the transform.
+	if (
+		( results.length === 1 && source.length > 1 ) ||
+		( results.length > 1 && source.length === 1 )
+	) {
+		return result;
+	}
+
+	// If we are transforming multiple blocks to multiple blocks with different counts,
+	// we ignore the metadata during the transform.
+	if (
+		results.length > 1 &&
+		source.length > 1 &&
+		results.length !== source.length
+	) {
+		return result;
+	}
+
+	const sourceMetadata = source[ index ]?.attributes?.metadata;
+
+	if ( ! sourceMetadata ) {
+		return result;
+	}
+
+	const preservedMetadata = {};
+
+	// Notes
+	if ( sourceMetadata.noteId && ! result.attributes?.metadata?.noteId ) {
+		preservedMetadata.noteId = sourceMetadata.noteId;
+	}
+
+	// Custom name
+	if (
+		sourceMetadata.name &&
+		! result.attributes?.metadata?.name &&
+		hasBlockSupport( result.name, 'renaming', true )
+	) {
+		preservedMetadata.name = sourceMetadata.name;
+	}
+
+	// Block visibility
+	if (
+		sourceMetadata.blockVisibility !== undefined &&
+		! result.attributes?.metadata?.blockVisibility &&
+		hasBlockSupport( result.name, 'blockVisibility', true )
+	) {
+		preservedMetadata.blockVisibility = sourceMetadata.blockVisibility;
+	}
+
+	if ( Object.keys( preservedMetadata ).length > 0 ) {
+		return {
+			...result,
+			attributes: {
+				...result.attributes,
+				metadata: {
+					...result.attributes.metadata,
+					...preservedMetadata,
+				},
+			},
+		};
+	}
+	return result;
+}
+
 addFilter(
 	'blocks.registerBlockType',
 	'core/metadata/addMetaAttribute',
 	addMetaAttribute
 );
+
+addFilter(
+	'blocks.switchToBlockType.transformedBlock',
+	'core/metadata/addTransforms',
+	addTransforms
+);

package/src/hooks/test/allowed-blocks.js

@@ -0,0 +1,278 @@
+/**
+ * WordPress dependencies
+ */
+import {
+	getBlockTypes,
+	registerBlockType,
+	unregisterBlockType,
+} from '@wordpress/blocks';
+
+/**
+ * Internal dependencies
+ */
+import { addTransforms } from '../allowed-blocks';
+
+describe( 'allowedBlocks', () => {
+	afterEach( () => {
+		getBlockTypes().forEach( ( block ) => {
+			unregisterBlockType( block.name );
+		} );
+	} );
+
+	describe( 'addTransforms()', () => {
+		it( 'should not preserve allowedBlocks in wrapping transforms', () => {
+			registerBlockType( 'core/bar', {
+				title: 'Bar',
+				supports: { allowedBlocks: true },
+			} );
+
+			const source = [
+				{
+					name: 'core/foo',
+					attributes: {
+						allowedBlocks: [ 'core/paragraph', 'core/heading' ],
+					},
+					innerBlocks: [],
+				},
+				{
+					name: 'core/foo',
+					attributes: { allowedBlocks: [ 'core/paragraph' ] },
+					innerBlocks: [],
+				},
+			];
+			const result = {
+				name: 'core/bar',
+				attributes: {},
+				innerBlocks: source,
+			};
+
+			const transformed = addTransforms( result, source, 0, [ result ] );
+
+			expect( transformed.attributes.allowedBlocks ).toBeUndefined();
+		} );
+
+		it( 'should not preserve allowedBlocks in one-to-many transforms', () => {
+			registerBlockType( 'core/bar', {
+				title: 'Bar',
+				supports: { allowedBlocks: true },
+			} );
+
+			const source = [
+				{
+					name: 'core/foo',
+					attributes: {
+						allowedBlocks: [ 'core/paragraph', 'core/heading' ],
+					},
+					innerBlocks: [],
+				},
+			];
+			const results = [
+				{ name: 'core/bar', attributes: {}, innerBlocks: [] },
+				{ name: 'core/bar', attributes: {}, innerBlocks: [] },
+			];
+
+			const transformed = addTransforms(
+				results[ 0 ],
+				source,
+				0,
+				results
+			);
+
+			expect( transformed.attributes.allowedBlocks ).toBeUndefined();
+		} );
+
+		it( 'should not preserve allowedBlocks in many-to-one transforms', () => {
+			registerBlockType( 'core/bar', {
+				title: 'Bar',
+				supports: { allowedBlocks: true },
+			} );
+
+			const source = [
+				{
+					name: 'core/foo',
+					attributes: {
+						allowedBlocks: [ 'core/paragraph', 'core/heading' ],
+					},
+					innerBlocks: [],
+				},
+				{
+					name: 'core/foo',
+					attributes: { allowedBlocks: [ 'core/paragraph' ] },
+					innerBlocks: [],
+				},
+			];
+			const result = {
+				name: 'core/bar',
+				attributes: {},
+				innerBlocks: [],
+			};
+
+			const transformed = addTransforms( result, source, 0, [ result ] );
+
+			expect( transformed.attributes.allowedBlocks ).toBeUndefined();
+		} );
+
+		it( 'should not preserve allowedBlocks in many-to-many transforms with different counts', () => {
+			registerBlockType( 'core/bar', {
+				title: 'Bar',
+				supports: { allowedBlocks: true },
+			} );
+
+			const source = [
+				{
+					name: 'core/foo',
+					attributes: {
+						allowedBlocks: [ 'core/paragraph', 'core/heading' ],
+					},
+					innerBlocks: [],
+				},
+				{
+					name: 'core/foo',
+					attributes: { allowedBlocks: [ 'core/paragraph' ] },
+					innerBlocks: [],
+				},
+				{
+					name: 'core/foo',
+					attributes: { allowedBlocks: [ 'core/heading' ] },
+					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.allowedBlocks ).toBeUndefined();
+			expect(
+				secondTransformed.attributes.allowedBlocks
+			).toBeUndefined();
+		} );
+
+		it( 'should preserve allowedBlocks in many-to-many transforms with same counts', () => {
+			registerBlockType( 'core/bar', {
+				title: 'Bar',
+				supports: { allowedBlocks: true },
+			} );
+
+			const source = [
+				{
+					name: 'core/foo',
+					attributes: {
+						allowedBlocks: [ 'core/image', 'core/heading' ],
+					},
+					innerBlocks: [],
+				},
+				{
+					name: 'core/foo',
+					attributes: { allowedBlocks: [ 'core/paragraph' ] },
+					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.allowedBlocks ).toEqual( [
+				'core/image',
+				'core/heading',
+			] );
+			expect( secondTransformed.attributes.allowedBlocks ).toEqual( [
+				'core/paragraph',
+			] );
+		} );
+
+		it( "should filter allowedBlocks based on destination block's allowedBlocks", () => {
+			registerBlockType( 'core/bar', {
+				title: 'Bar',
+				supports: { allowedBlocks: true },
+				allowedBlocks: [ 'core/paragraph' ],
+			} );
+
+			const source = [
+				{
+					name: 'core/foo',
+					attributes: {
+						allowedBlocks: [
+							'core/paragraph',
+							'core/heading',
+							'core/image',
+						],
+					},
+					innerBlocks: [],
+				},
+			];
+			const result = {
+				name: 'core/bar',
+				attributes: {},
+				innerBlocks: [],
+			};
+
+			const transformed = addTransforms( result, source, 0, [ result ] );
+
+			expect( transformed.attributes.allowedBlocks ).toEqual( [
+				'core/paragraph',
+			] );
+		} );
+
+		it( 'should not override existing allowedBlocks in target block', () => {
+			registerBlockType( 'core/bar', {
+				title: 'Bar',
+				supports: { allowedBlocks: true },
+			} );
+
+			const source = [
+				{
+					name: 'core/foo',
+					attributes: { allowedBlocks: [ 'core/paragraph' ] },
+					innerBlocks: [],
+				},
+			];
+			const result = {
+				name: 'core/bar',
+				attributes: { allowedBlocks: [ 'core/heading' ] },
+				innerBlocks: [],
+			};
+
+			const transformed = addTransforms( result, source, 0, [ result ] );
+
+			expect( transformed.attributes.allowedBlocks ).toEqual( [
+				'core/heading',
+			] );
+		} );
+
+		it( 'should not preserve allowedBlocks when target block does not support allowedBlocks', () => {
+			registerBlockType( 'core/bar', {
+				title: 'Bar',
+			} );
+
+			const source = [
+				{
+					name: 'core/foo',
+					attributes: {
+						allowedBlocks: [ 'core/paragraph', 'core/heading' ],
+					},
+					innerBlocks: [],
+				},
+			];
+			const result = {
+				name: 'core/bar',
+				attributes: {},
+				innerBlocks: [],
+			};
+			const transformed = addTransforms( result, source, 0, [ result ] );
+
+			expect( transformed.attributes.allowedBlocks ).toBeUndefined();
+		} );
+	} );
+} );

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,
+			} );
+		} );
+	} );
+} );