Re-evaluate shortcode blocks for more specific shortcode transforms

[ccprog]

We're currently in a situation where some plugins using shortcodes do not yet convert them to blocks, but might do so at a later time.

This leads to the following scenario: A user has content containing shortcodes. He/she opens it in the Gutenberg editor and converts it to blocks. The shortcodes will be converted to a core/shortcode block. Later (and this might happen for a long time) the plugin developer decides to provide a conversion specific to his/her shortcodes. This transformation will never match the shortcode block, because it is only considered for raw handling.

For my plugin, I was able to solve this with a second from-transform:

{
    type: 'block',
    blocks: ['core/shortcode'],
    isMatch: ( {text} ) => {
        const re = wp.shortcode.regexp('crosswordsearch');
        return re.test(text);
    },
    transform: ( {text} ) => {
        return wp.blocks.rawHandler({
            HTML: '<p>' + text + '</p>',
            mode: 'BLOCKS'
        });
    },
    priority: 15
}

Instead of every developer implementing something like this, it would be much better to define this as a to-transform on the core/shortcode block with

• a blocks list of all block type names that offer type: 'shortcode' from-transforms.
• isMatch testing for all the tags named in those block types

[aduth]

If I understand correctly, is the issue that a block can define that it be transformed from a shortcode, but if the content is already migrated to a "Shortcode" block, then these won't be considered as candidates?

Example Gallery shortcode transform:

gutenberg/packages/block-library/src/gallery/transforms.js

Lines 54 to 85 in 1d2d1fc

	{
	type: 'shortcode',
	tag: 'gallery',
	attributes: {
	images: {
	type: 'array',
	shortcode: ( { named: { ids } } ) => {
	return parseShortcodeIds( ids ).map( ( id ) => ( {
	id,
	} ) );
	},
	},
	ids: {
	type: 'array',
	shortcode: ( { named: { ids } } ) => {
	return parseShortcodeIds( ids );
	},
	},
	columns: {
	type: 'number',
	shortcode: ( { named: { columns = '3' } } ) => {
	return parseInt( columns, 10 );
	},
	},
	linkTo: {
	type: 'string',
	shortcode: ( { named: { link = 'attachment' } } ) => {
	return link === 'file' ? 'media' : link;
	},
	},
	},
	},

It would not identify a possible transform if, for example, a user had content:

<!-- wp:shortcode -->
[gallery]
<!-- /wp:shortcode -->

This makes sense to me as an area for improvement. In particular, we may consider to treat shortcode blocks as their raw shortcode counterparts when trying to determine transforms for Shortcode block.

In the UI then:

... should present transform options to convert this Shortcode block to Gallery.

[mcsf]

This seems like a quick win. /cc @ellatrix