@wordpress/block-editor 10.4.0 → 11.0.0

package/src/store/test/selectors.js

@@ -44,6 +44,7 @@ const {
 	isBlockMultiSelected,
 	isFirstMultiSelectedBlock,
 	getBlockMode,
+	__experimentalIsBlockInterfaceHidden: isBlockInterfaceHidden,
 	isTyping,
 	isDraggingBlocks,
 	getDraggedBlockClientIds,
@@ -72,6 +73,7 @@ const {
 	__experimentalGetPatternTransformItems,
 	wasBlockJustInserted,
 	__experimentalGetGlobalBlocksByName,
+	getLastInsertedBlockClientId,
 } = selectors;
 
 describe( 'selectors', () => {
@@ -201,10 +203,10 @@ describe( 'selectors', () => {
 		it( 'returns null if no block by clientId', () => {
 			const state = {
 				blocks: {
-					byClientId: {},
+					byClientId: new Map(),
 					attributes: {},
-					order: {},
-					parents: {},
+					order: new Map(),
+					parents: new Map(),
 				},
 			};
 
@@ -219,22 +221,31 @@ describe( 'selectors', () => {
 		it( 'returns block name', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						'afd1cb17-2c08-4e7a-91be-007ba7ddc3a1': {
-							clientId: 'afd1cb17-2c08-4e7a-91be-007ba7ddc3a1',
-							name: 'core/paragraph',
-						},
-					},
-					attributes: {
-						'afd1cb17-2c08-4e7a-91be-007ba7ddc3a1': {},
-					},
-					order: {
-						'': [ 'afd1cb17-2c08-4e7a-91be-007ba7ddc3a1' ],
-						'afd1cb17-2c08-4e7a-91be-007ba7ddc3a1': [],
-					},
-					parents: {
-						'afd1cb17-2c08-4e7a-91be-007ba7ddc3a1': '',
-					},
+					byClientId: new Map(
+						Object.entries( {
+							'afd1cb17-2c08-4e7a-91be-007ba7ddc3a1': {
+								clientId:
+									'afd1cb17-2c08-4e7a-91be-007ba7ddc3a1',
+								name: 'core/paragraph',
+							},
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							'afd1cb17-2c08-4e7a-91be-007ba7ddc3a1': {},
+						} )
+					),
+					order: new Map(
+						Object.entries( {
+							'': [ 'afd1cb17-2c08-4e7a-91be-007ba7ddc3a1' ],
+							'afd1cb17-2c08-4e7a-91be-007ba7ddc3a1': [],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							'afd1cb17-2c08-4e7a-91be-007ba7ddc3a1': '',
+						} )
+					),
 				},
 			};
 
@@ -251,54 +262,68 @@ describe( 'selectors', () => {
 		it( 'should return the block', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						123: { clientId: 123, name: 'core/paragraph' },
-					},
-					attributes: {
-						123: {},
-					},
-					order: {
-						'': [ 123 ],
-						123: [],
-					},
-					parents: {
-						123: '',
-					},
-					tree: {
-						123: {
-							clientId: 123,
-							name: 'core/paragraph',
-							attributes: {},
-							innerBlocks: [],
-						},
-					},
+					byClientId: new Map(
+						Object.entries( {
+							123: { clientId: '123', name: 'core/paragraph' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							123: {},
+						} )
+					),
+					order: new Map(
+						Object.entries( {
+							'': [ '123' ],
+							123: [],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							123: '',
+						} )
+					),
+					tree: new Map(
+						Object.entries( {
+							123: {
+								clientId: '123',
+								name: 'core/paragraph',
+								attributes: {},
+								innerBlocks: [],
+							},
+						} )
+					),
 					controlledInnerBlocks: {},
 				},
 			};
 
-			expect( getBlock( state, 123 ) ).toBe( state.blocks.tree[ 123 ] );
+			expect( getBlock( state, '123' ) ).toBe(
+				state.blocks.tree.get( '123' )
+			);
 		} );
 
 		it( 'should return null if the block is not present in state', () => {
 			const state = {
 				blocks: {
-					byClientId: {},
-					attributes: {},
-					order: {},
-					parents: {},
-					tree: {
-						123: {
-							clientId: 123,
-							name: 'core/paragraph',
-							attributes: {},
-							innerBlocks: [],
-						},
-					},
+					byClientId: new Map(),
+					attributes: new Map(),
+					order: new Map(),
+					parents: new Map(),
+					tree: new Map(
+						Object.entries( {
+							123: {
+								clientId: '123',
+								name: 'core/paragraph',
+								attributes: {},
+								innerBlocks: [],
+							},
+						} )
+					),
 					controlledInnerBlocks: {},
 				},
 			};
 
-			expect( getBlock( state, 123 ) ).toBe( null );
+			expect( getBlock( state, '123' ) ).toBe( null );
 		} );
 	} );
 
@@ -306,47 +331,57 @@ describe( 'selectors', () => {
 		it( 'should return the ordered blocks', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						23: { clientId: 23, name: 'core/heading' },
-						123: { clientId: 123, name: 'core/paragraph' },
-					},
-					attributes: {
-						23: {},
-						123: {},
-					},
-					order: {
-						'': [ 123, 23 ],
-					},
-					parents: {
-						123: '',
-						23: '',
-					},
-					tree: {
-						'': {
-							innerBlocks: [
-								{
-									clientId: 123,
-									name: 'core/paragraph',
-									attributes: {},
-									innerBlocks: [],
-								},
-								{
-									clientId: 23,
-									name: 'core/heading',
-									attributes: {},
-									innerBlocks: [],
-								},
-							],
-						},
-						123: {},
-						23: {},
-					},
+					byClientId: new Map(
+						Object.entries( {
+							23: { clientId: '23', name: 'core/heading' },
+							123: { clientId: '123', name: 'core/paragraph' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							23: {},
+							123: {},
+						} )
+					),
+					order: new Map(
+						Object.entries( {
+							'': [ '123', '23' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							123: '',
+							23: '',
+						} )
+					),
+					tree: new Map(
+						Object.entries( {
+							'': {
+								innerBlocks: [
+									{
+										clientId: '123',
+										name: 'core/paragraph',
+										attributes: {},
+										innerBlocks: [],
+									},
+									{
+										clientId: '23',
+										name: 'core/heading',
+										attributes: {},
+										innerBlocks: [],
+									},
+								],
+							},
+							123: {},
+							23: {},
+						} )
+					),
 					controlledInnerBlocks: {},
 				},
 			};
 
 			expect( getBlocks( state ) ).toBe(
-				state.blocks.tree[ '' ].innerBlocks
+				state.blocks.tree.get( '' ).innerBlocks
 			);
 		} );
 	} );
@@ -355,30 +390,34 @@ describe( 'selectors', () => {
 		it( 'should return parent blocks', () => {
 			const state = {
 				blocks: {
-					parents: {
-						'client-id-01': '',
-						'client-id-02': 'client-id-01',
-						'client-id-03': 'client-id-02',
-						'client-id-04': 'client-id-03',
-					},
-					byClientId: {
-						'client-id-01': {
-							clientId: 'client-id-01',
-							name: 'core/columns',
-						},
-						'client-id-02': {
-							clientId: 'client-id-02',
-							name: 'core/navigation',
-						},
-						'client-id-03': {
-							clientId: 'client-id-03',
-							name: 'core/navigation-link',
-						},
-						'client-id-04': {
-							clientId: 'client-id-04',
-							name: 'core/paragraph',
-						},
-					},
+					parents: new Map(
+						Object.entries( {
+							'client-id-01': '',
+							'client-id-02': 'client-id-01',
+							'client-id-03': 'client-id-02',
+							'client-id-04': 'client-id-03',
+						} )
+					),
+					byClientId: new Map(
+						Object.entries( {
+							'client-id-01': {
+								clientId: 'client-id-01',
+								name: 'core/columns',
+							},
+							'client-id-02': {
+								clientId: 'client-id-02',
+								name: 'core/navigation',
+							},
+							'client-id-03': {
+								clientId: 'client-id-03',
+								name: 'core/navigation-link',
+							},
+							'client-id-04': {
+								clientId: 'client-id-04',
+								name: 'core/paragraph',
+							},
+						} )
+					),
 					cache: {
 						'client-id-01': {},
 						'client-id-02': {},
@@ -402,35 +441,39 @@ describe( 'selectors', () => {
 	describe( 'getBlockParentsByBlockName', () => {
 		const state = {
 			blocks: {
-				parents: {
-					'client-id-01': '',
-					'client-id-02': 'client-id-01',
-					'client-id-03': 'client-id-02',
-					'client-id-04': 'client-id-03',
-					'client-id-05': 'client-id-04',
-				},
-				byClientId: {
-					'client-id-01': {
-						clientId: 'client-id-01',
-						name: 'core/navigation',
-					},
-					'client-id-02': {
-						clientId: 'client-id-02',
-						name: 'core/columns',
-					},
-					'client-id-03': {
-						clientId: 'client-id-03',
-						name: 'core/navigation',
-					},
-					'client-id-04': {
-						clientId: 'client-id-04',
-						name: 'core/navigation-link',
-					},
-					'client-id-05': {
-						clientId: 'client-id-05',
-						name: 'core/navigation-link',
-					},
-				},
+				parents: new Map(
+					Object.entries( {
+						'client-id-01': '',
+						'client-id-02': 'client-id-01',
+						'client-id-03': 'client-id-02',
+						'client-id-04': 'client-id-03',
+						'client-id-05': 'client-id-04',
+					} )
+				),
+				byClientId: new Map(
+					Object.entries( {
+						'client-id-01': {
+							clientId: 'client-id-01',
+							name: 'core/navigation',
+						},
+						'client-id-02': {
+							clientId: 'client-id-02',
+							name: 'core/columns',
+						},
+						'client-id-03': {
+							clientId: 'client-id-03',
+							name: 'core/navigation',
+						},
+						'client-id-04': {
+							clientId: 'client-id-04',
+							name: 'core/navigation-link',
+						},
+						'client-id-05': {
+							clientId: 'client-id-05',
+							name: 'core/navigation-link',
+						},
+					} )
+				),
 				cache: {
 					'client-id-01': {},
 					'client-id-02': {},
@@ -486,89 +529,124 @@ describe( 'selectors', () => {
 		it( 'should return the ids of any descendants in sequential order, given an array of clientIds', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						'uuid-2': { clientId: 'uuid-2', name: 'core/image' },
-						'uuid-4': {
-							clientId: 'uuid-4',
-							name: 'core/paragraph',
-						},
-						'uuid-6': {
-							clientId: 'uuid-6',
-							name: 'core/paragraph',
-						},
-						'uuid-8': { clientId: 'uuid-8', name: 'core/block' },
-						'uuid-10': {
-							clientId: 'uuid-10',
-							name: 'core/columns',
-						},
-						'uuid-12': { clientId: 'uuid-12', name: 'core/column' },
-						'uuid-14': { clientId: 'uuid-14', name: 'core/column' },
-						'uuid-16': { clientId: 'uuid-16', name: 'core/quote' },
-						'uuid-18': { clientId: 'uuid-18', name: 'core/block' },
-						'uuid-20': {
-							clientId: 'uuid-20',
-							name: 'core/gallery',
-						},
-						'uuid-22': { clientId: 'uuid-22', name: 'core/block' },
-						'uuid-24': {
-							clientId: 'uuid-24',
-							name: 'core/columns',
-						},
-						'uuid-26': { clientId: 'uuid-26', name: 'core/column' },
-						'uuid-28': { clientId: 'uuid-28', name: 'core/column' },
-						'uuid-30': {
-							clientId: 'uuid-30',
-							name: 'core/paragraph',
-						},
-					},
-					attributes: {
-						'uuid-2': {},
-						'uuid-4': {},
-						'uuid-6': {},
-						'uuid-8': {},
-						'uuid-10': {},
-						'uuid-12': {},
-						'uuid-14': {},
-						'uuid-16': {},
-						'uuid-18': {},
-						'uuid-20': {},
-						'uuid-22': {},
-						'uuid-24': {},
-						'uuid-26': {},
-						'uuid-28': {},
-						'uuid-30': {},
-					},
-					order: {
-						'': [ 'uuid-6', 'uuid-8', 'uuid-10', 'uuid-22' ],
-						'uuid-2': [],
-						'uuid-4': [],
-						'uuid-6': [],
-						'uuid-8': [],
-						'uuid-10': [ 'uuid-12', 'uuid-14' ],
-						'uuid-12': [ 'uuid-16' ],
-						'uuid-14': [ 'uuid-18' ],
-						'uuid-16': [],
-						'uuid-18': [ 'uuid-24' ],
-						'uuid-20': [],
-						'uuid-22': [],
-						'uuid-24': [ 'uuid-26', 'uuid-28' ],
-						'uuid-26': [],
-						'uuid-28': [ 'uuid-30' ],
-					},
-					parents: {
-						'uuid-6': '',
-						'uuid-8': '',
-						'uuid-10': '',
-						'uuid-22': '',
-						'uuid-12': 'uuid-10',
-						'uuid-14': 'uuid-10',
-						'uuid-16': 'uuid-12',
-						'uuid-18': 'uuid-14',
-						'uuid-24': 'uuid-18',
-						'uuid-26': 'uuid-24',
-						'uuid-28': 'uuid-24',
-						'uuid-30': 'uuid-28',
-					},
+					byClientId: new Map(
+						Object.entries( {
+							'uuid-2': {
+								clientId: 'uuid-2',
+								name: 'core/image',
+							},
+							'uuid-4': {
+								clientId: 'uuid-4',
+								name: 'core/paragraph',
+							},
+							'uuid-6': {
+								clientId: 'uuid-6',
+								name: 'core/paragraph',
+							},
+							'uuid-8': {
+								clientId: 'uuid-8',
+								name: 'core/block',
+							},
+							'uuid-10': {
+								clientId: 'uuid-10',
+								name: 'core/columns',
+							},
+							'uuid-12': {
+								clientId: 'uuid-12',
+								name: 'core/column',
+							},
+							'uuid-14': {
+								clientId: 'uuid-14',
+								name: 'core/column',
+							},
+							'uuid-16': {
+								clientId: 'uuid-16',
+								name: 'core/quote',
+							},
+							'uuid-18': {
+								clientId: 'uuid-18',
+								name: 'core/block',
+							},
+							'uuid-20': {
+								clientId: 'uuid-20',
+								name: 'core/gallery',
+							},
+							'uuid-22': {
+								clientId: 'uuid-22',
+								name: 'core/block',
+							},
+							'uuid-24': {
+								clientId: 'uuid-24',
+								name: 'core/columns',
+							},
+							'uuid-26': {
+								clientId: 'uuid-26',
+								name: 'core/column',
+							},
+							'uuid-28': {
+								clientId: 'uuid-28',
+								name: 'core/column',
+							},
+							'uuid-30': {
+								clientId: 'uuid-30',
+								name: 'core/paragraph',
+							},
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							'uuid-2': {},
+							'uuid-4': {},
+							'uuid-6': {},
+							'uuid-8': {},
+							'uuid-10': {},
+							'uuid-12': {},
+							'uuid-14': {},
+							'uuid-16': {},
+							'uuid-18': {},
+							'uuid-20': {},
+							'uuid-22': {},
+							'uuid-24': {},
+							'uuid-26': {},
+							'uuid-28': {},
+							'uuid-30': {},
+						} )
+					),
+					order: new Map(
+						Object.entries( {
+							'': [ 'uuid-6', 'uuid-8', 'uuid-10', 'uuid-22' ],
+							'uuid-2': [],
+							'uuid-4': [],
+							'uuid-6': [],
+							'uuid-8': [],
+							'uuid-10': [ 'uuid-12', 'uuid-14' ],
+							'uuid-12': [ 'uuid-16' ],
+							'uuid-14': [ 'uuid-18' ],
+							'uuid-16': [],
+							'uuid-18': [ 'uuid-24' ],
+							'uuid-20': [],
+							'uuid-22': [],
+							'uuid-24': [ 'uuid-26', 'uuid-28' ],
+							'uuid-26': [],
+							'uuid-28': [ 'uuid-30' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							'uuid-6': '',
+							'uuid-8': '',
+							'uuid-10': '',
+							'uuid-22': '',
+							'uuid-12': 'uuid-10',
+							'uuid-14': 'uuid-10',
+							'uuid-16': 'uuid-12',
+							'uuid-18': 'uuid-14',
+							'uuid-24': 'uuid-18',
+							'uuid-26': 'uuid-24',
+							'uuid-28': 'uuid-24',
+							'uuid-30': 'uuid-28',
+						} )
+					),
 					controlledInnerBlocks: {},
 				},
 			};
@@ -591,89 +669,124 @@ describe( 'selectors', () => {
 		it( 'should return the ids for top-level blocks and their descendants of any depth (for nested blocks) in sequential order.', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						'uuid-2': { clientId: 'uuid-2', name: 'core/image' },
-						'uuid-4': {
-							clientId: 'uuid-4',
-							name: 'core/paragraph',
-						},
-						'uuid-6': {
-							clientId: 'uuid-6',
-							name: 'core/paragraph',
-						},
-						'uuid-8': { clientId: 'uuid-8', name: 'core/block' },
-						'uuid-10': {
-							clientId: 'uuid-10',
-							name: 'core/columns',
-						},
-						'uuid-12': { clientId: 'uuid-12', name: 'core/column' },
-						'uuid-14': { clientId: 'uuid-14', name: 'core/column' },
-						'uuid-16': { clientId: 'uuid-16', name: 'core/quote' },
-						'uuid-18': { clientId: 'uuid-18', name: 'core/block' },
-						'uuid-20': {
-							clientId: 'uuid-20',
-							name: 'core/gallery',
-						},
-						'uuid-22': { clientId: 'uuid-22', name: 'core/block' },
-						'uuid-24': {
-							clientId: 'uuid-24',
-							name: 'core/columns',
-						},
-						'uuid-26': { clientId: 'uuid-26', name: 'core/column' },
-						'uuid-28': { clientId: 'uuid-28', name: 'core/column' },
-						'uuid-30': {
-							clientId: 'uuid-30',
-							name: 'core/paragraph',
-						},
-					},
-					attributes: {
-						'uuid-2': {},
-						'uuid-4': {},
-						'uuid-6': {},
-						'uuid-8': {},
-						'uuid-10': {},
-						'uuid-12': {},
-						'uuid-14': {},
-						'uuid-16': {},
-						'uuid-18': {},
-						'uuid-20': {},
-						'uuid-22': {},
-						'uuid-24': {},
-						'uuid-26': {},
-						'uuid-28': {},
-						'uuid-30': {},
-					},
-					order: {
-						'': [ 'uuid-6', 'uuid-8', 'uuid-10', 'uuid-22' ],
-						'uuid-2': [],
-						'uuid-4': [],
-						'uuid-6': [],
-						'uuid-8': [],
-						'uuid-10': [ 'uuid-12', 'uuid-14' ],
-						'uuid-12': [ 'uuid-16' ],
-						'uuid-14': [ 'uuid-18' ],
-						'uuid-16': [],
-						'uuid-18': [ 'uuid-24' ],
-						'uuid-20': [],
-						'uuid-22': [],
-						'uuid-24': [ 'uuid-26', 'uuid-28' ],
-						'uuid-26': [],
-						'uuid-28': [ 'uuid-30' ],
-					},
-					parents: {
-						'uuid-6': '',
-						'uuid-8': '',
-						'uuid-10': '',
-						'uuid-22': '',
-						'uuid-12': 'uuid-10',
-						'uuid-14': 'uuid-10',
-						'uuid-16': 'uuid-12',
-						'uuid-18': 'uuid-14',
-						'uuid-24': 'uuid-18',
-						'uuid-26': 'uuid-24',
-						'uuid-28': 'uuid-24',
-						'uuid-30': 'uuid-28',
-					},
+					byClientId: new Map(
+						Object.entries( {
+							'uuid-2': {
+								clientId: 'uuid-2',
+								name: 'core/image',
+							},
+							'uuid-4': {
+								clientId: 'uuid-4',
+								name: 'core/paragraph',
+							},
+							'uuid-6': {
+								clientId: 'uuid-6',
+								name: 'core/paragraph',
+							},
+							'uuid-8': {
+								clientId: 'uuid-8',
+								name: 'core/block',
+							},
+							'uuid-10': {
+								clientId: 'uuid-10',
+								name: 'core/columns',
+							},
+							'uuid-12': {
+								clientId: 'uuid-12',
+								name: 'core/column',
+							},
+							'uuid-14': {
+								clientId: 'uuid-14',
+								name: 'core/column',
+							},
+							'uuid-16': {
+								clientId: 'uuid-16',
+								name: 'core/quote',
+							},
+							'uuid-18': {
+								clientId: 'uuid-18',
+								name: 'core/block',
+							},
+							'uuid-20': {
+								clientId: 'uuid-20',
+								name: 'core/gallery',
+							},
+							'uuid-22': {
+								clientId: 'uuid-22',
+								name: 'core/block',
+							},
+							'uuid-24': {
+								clientId: 'uuid-24',
+								name: 'core/columns',
+							},
+							'uuid-26': {
+								clientId: 'uuid-26',
+								name: 'core/column',
+							},
+							'uuid-28': {
+								clientId: 'uuid-28',
+								name: 'core/column',
+							},
+							'uuid-30': {
+								clientId: 'uuid-30',
+								name: 'core/paragraph',
+							},
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							'uuid-2': {},
+							'uuid-4': {},
+							'uuid-6': {},
+							'uuid-8': {},
+							'uuid-10': {},
+							'uuid-12': {},
+							'uuid-14': {},
+							'uuid-16': {},
+							'uuid-18': {},
+							'uuid-20': {},
+							'uuid-22': {},
+							'uuid-24': {},
+							'uuid-26': {},
+							'uuid-28': {},
+							'uuid-30': {},
+						} )
+					),
+					order: new Map(
+						Object.entries( {
+							'': [ 'uuid-6', 'uuid-8', 'uuid-10', 'uuid-22' ],
+							'uuid-2': [],
+							'uuid-4': [],
+							'uuid-6': [],
+							'uuid-8': [],
+							'uuid-10': [ 'uuid-12', 'uuid-14' ],
+							'uuid-12': [ 'uuid-16' ],
+							'uuid-14': [ 'uuid-18' ],
+							'uuid-16': [],
+							'uuid-18': [ 'uuid-24' ],
+							'uuid-20': [],
+							'uuid-22': [],
+							'uuid-24': [ 'uuid-26', 'uuid-28' ],
+							'uuid-26': [],
+							'uuid-28': [ 'uuid-30' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							'uuid-6': '',
+							'uuid-8': '',
+							'uuid-10': '',
+							'uuid-22': '',
+							'uuid-12': 'uuid-10',
+							'uuid-14': 'uuid-10',
+							'uuid-16': 'uuid-12',
+							'uuid-18': 'uuid-14',
+							'uuid-24': 'uuid-18',
+							'uuid-26': 'uuid-24',
+							'uuid-28': 'uuid-24',
+							'uuid-30': 'uuid-28',
+						} )
+					),
 				},
 			};
 			expect( getClientIdsWithDescendants( state ) ).toEqual( [
@@ -697,17 +810,23 @@ describe( 'selectors', () => {
 		it( 'should return the number of top-level blocks in the post', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						23: { clientId: 23, name: 'core/heading' },
-						123: { clientId: 123, name: 'core/paragraph' },
-					},
-					attributes: {
-						23: {},
-						123: {},
-					},
-					order: {
-						'': [ 123, 23 ],
-					},
+					byClientId: new Map(
+						Object.entries( {
+							23: { clientId: '23', name: 'core/heading' },
+							123: { clientId: '123', name: 'core/paragraph' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							23: {},
+							123: {},
+						} )
+					),
+					order: new Map(
+						Object.entries( {
+							'': [ '123', '23' ],
+						} )
+					),
 				},
 			};
 
@@ -717,25 +836,33 @@ describe( 'selectors', () => {
 		it( 'should return the number of blocks in a nested context', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						123: { clientId: 123, name: 'core/columns' },
-						456: { clientId: 456, name: 'core/paragraph' },
-						789: { clientId: 789, name: 'core/paragraph' },
-					},
-					attributes: {
-						123: {},
-						456: {},
-						789: {},
-					},
-					order: {
-						'': [ 123 ],
-						123: [ 456, 789 ],
-					},
-					parents: {
-						123: '',
-						456: 123,
-						789: 123,
-					},
+					byClientId: new Map(
+						Object.entries( {
+							123: { clientId: '123', name: 'core/columns' },
+							456: { clientId: '456', name: 'core/paragraph' },
+							789: { clientId: '789', name: 'core/paragraph' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							123: {},
+							456: {},
+							789: {},
+						} )
+					),
+					order: new Map(
+						Object.entries( {
+							'': [ '123' ],
+							123: [ '456', '789' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							123: '',
+							456: '123',
+							789: '123',
+						} )
+					),
 				},
 			};
 
@@ -789,23 +916,31 @@ describe( 'selectors', () => {
 	describe( 'getGlobalBlockCount', () => {
 		const state = {
 			blocks: {
-				byClientId: {
-					123: { clientId: 123, name: 'core/heading' },
-					456: { clientId: 456, name: 'core/paragraph' },
-					789: { clientId: 789, name: 'core/paragraph' },
-				},
-				attributes: {
-					123: {},
-					456: {},
-					789: {},
-				},
-				order: {
-					'': [ 123, 456 ],
-				},
-				parents: {
-					123: '',
-					456: '',
-				},
+				byClientId: new Map(
+					Object.entries( {
+						123: { clientId: '123', name: 'core/heading' },
+						456: { clientId: '456', name: 'core/paragraph' },
+						789: { clientId: '789', name: 'core/paragraph' },
+					} )
+				),
+				attributes: new Map(
+					Object.entries( {
+						123: {},
+						456: {},
+						789: {},
+					} )
+				),
+				order: new Map(
+					Object.entries( {
+						'': [ '123', '456' ],
+					} )
+				),
+				parents: new Map(
+					Object.entries( {
+						123: '',
+						456: '',
+					} )
+				),
 			},
 		};
 
@@ -820,10 +955,10 @@ describe( 'selectors', () => {
 		it( 'should return 0 if no blocks exist', () => {
 			const emptyState = {
 				blocks: {
-					byClientId: {},
-					attributes: {},
-					order: {},
-					parents: {},
+					byClientId: new Map(),
+					attributes: new Map(),
+					order: new Map(),
+					parents: new Map(),
 				},
 			};
 			expect( getGlobalBlockCount( emptyState ) ).toBe( 0 );
@@ -836,46 +971,54 @@ describe( 'selectors', () => {
 	describe( '__experimentalGetGlobalBlocksByName', () => {
 		const state = {
 			blocks: {
-				byClientId: {
-					123: { clientId: 123, name: 'core/heading' },
-					456: { clientId: 456, name: 'core/paragraph' },
-					789: { clientId: 789, name: 'core/paragraph' },
-					1011: { clientId: 1011, name: 'core/group' },
-					1213: { clientId: 1213, name: 'core/paragraph' },
-					1415: { clientId: 1213, name: 'core/paragraph' },
-				},
-				attributes: {
-					123: {},
-					456: {},
-					789: {},
-					1011: {},
-					1213: {},
-					1415: {},
-				},
-				order: {
-					'': [ 123, 456, 1011 ],
-					1011: [ 1415, 1213 ],
-				},
-				parents: {
-					123: '',
-					456: '',
-					1011: '',
-					1213: 1011,
-					1415: 1011,
-				},
+				byClientId: new Map(
+					Object.entries( {
+						123: { clientId: '123', name: 'core/heading' },
+						456: { clientId: '456', name: 'core/paragraph' },
+						789: { clientId: '789', name: 'core/paragraph' },
+						1011: { clientId: '1011', name: 'core/group' },
+						1213: { clientId: '1213', name: 'core/paragraph' },
+						1415: { clientId: '1213', name: 'core/paragraph' },
+					} )
+				),
+				attributes: new Map(
+					Object.entries( {
+						123: {},
+						456: {},
+						789: {},
+						1011: {},
+						1213: {},
+						1415: {},
+					} )
+				),
+				order: new Map(
+					Object.entries( {
+						'': [ '123', '456', '1011' ],
+						1011: [ '1415', '1213' ],
+					} )
+				),
+				parents: new Map(
+					Object.entries( {
+						123: '',
+						456: '',
+						1011: '',
+						1213: '1011',
+						1415: '1011',
+					} )
+				),
 			},
 		};
 
 		it( 'should return the clientIds of blocks of a given type', () => {
 			expect(
 				__experimentalGetGlobalBlocksByName( state, 'core/heading' )
-			).toStrictEqual( [ 123 ] );
+			).toStrictEqual( [ '123' ] );
 		} );
 
 		it( 'should return the clientIds of blocks of a given type even if blocks are nested', () => {
 			expect(
 				__experimentalGetGlobalBlocksByName( state, 'core/paragraph' )
-			).toStrictEqual( [ 456, 1415, 1213 ] );
+			).toStrictEqual( [ '456', '1415', '1213' ] );
 		} );
 
 		it( 'Should return empty array if no blocks match. The empty array should be the same reference', () => {
@@ -910,8 +1053,8 @@ describe( 'selectors', () => {
 		it( 'should return null if there is multi selection', () => {
 			const state = {
 				selection: {
-					selectionStart: { clientId: 23 },
-					selectionEnd: { clientId: 123 },
+					selectionStart: { clientId: '23' },
+					selectionEnd: { clientId: '123' },
 				},
 			};
 
@@ -921,19 +1064,21 @@ describe( 'selectors', () => {
 		it( 'should return the selected block ClientId', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						23: {
-							name: 'fake block',
-						},
-					},
+					byClientId: new Map(
+						Object.entries( {
+							23: {
+								name: 'fake block',
+							},
+						} )
+					),
 				},
 				selection: {
-					selectionStart: { clientId: 23 },
-					selectionEnd: { clientId: 23 },
+					selectionStart: { clientId: '23' },
+					selectionEnd: { clientId: '23' },
 				},
 			};
 
-			expect( getSelectedBlockClientId( state ) ).toEqual( 23 );
+			expect( getSelectedBlockClientId( state ) ).toEqual( '23' );
 		} );
 	} );
 
@@ -941,31 +1086,41 @@ describe( 'selectors', () => {
 		it( 'should return null if no block is selected', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						23: { clientId: 23, name: 'core/heading' },
-						123: { clientId: 123, name: 'core/paragraph' },
-					},
-					attributes: {
-						23: {},
-						123: {},
-					},
-					order: {
-						'': [ 23, 123 ],
-						23: [],
-						123: [],
-					},
-					parents: {
-						23: '',
-						123: '',
-					},
-					tree: {
-						23: {
-							clientId: 23,
-							name: 'core/heading',
-							attributes: {},
-							innerBlocks: [],
-						},
-					},
+					byClientId: new Map(
+						Object.entries( {
+							23: { clientId: '23', name: 'core/heading' },
+							123: { clientId: '123', name: 'core/paragraph' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							23: {},
+							123: {},
+						} )
+					),
+					order: new Map(
+						Object.entries( {
+							'': [ '23', '123' ],
+							23: [],
+							123: [],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							23: '',
+							123: '',
+						} )
+					),
+					tree: new Map(
+						Object.entries( {
+							23: {
+								clientId: '23',
+								name: 'core/heading',
+								attributes: {},
+								innerBlocks: [],
+							},
+						} )
+					),
 				},
 				selection: {
 					selectionStart: {},
@@ -979,35 +1134,45 @@ describe( 'selectors', () => {
 		it( 'should return null if there is multi selection', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						23: { clientId: 23, name: 'core/heading' },
-						123: { clientId: 123, name: 'core/paragraph' },
-					},
-					attributes: {
-						23: {},
-						123: {},
-					},
-					order: {
-						'': [ 23, 123 ],
-						23: [],
-						123: [],
-					},
-					parents: {
-						123: '',
-						23: '',
-					},
-					tree: {
-						23: {
-							clientId: 23,
-							name: 'core/heading',
-							attributes: {},
-							innerBlocks: [],
-						},
-					},
+					byClientId: new Map(
+						Object.entries( {
+							23: { clientId: '23', name: 'core/heading' },
+							123: { clientId: '123', name: 'core/paragraph' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							23: {},
+							123: {},
+						} )
+					),
+					order: new Map(
+						Object.entries( {
+							'': [ '23', '123' ],
+							23: [],
+							123: [],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							123: '',
+							23: '',
+						} )
+					),
+					tree: new Map(
+						Object.entries( {
+							23: {
+								clientId: '23',
+								name: 'core/heading',
+								attributes: {},
+								innerBlocks: [],
+							},
+						} )
+					),
 				},
 				selection: {
-					selectionStart: { clientId: 23 },
-					selectionEnd: { clientId: 123 },
+					selectionStart: { clientId: '23' },
+					selectionEnd: { clientId: '123' },
 				},
 			};
 
@@ -1017,41 +1182,51 @@ describe( 'selectors', () => {
 		it( 'should return the selected block', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						23: { clientId: 23, name: 'core/heading' },
-						123: { clientId: 123, name: 'core/paragraph' },
-					},
-					attributes: {
-						23: {},
-						123: {},
-					},
-					order: {
-						'': [ 23, 123 ],
-						23: [],
-						123: [],
-					},
-					parents: {
-						123: '',
-						23: '',
-					},
-					tree: {
-						23: {
-							clientId: 23,
-							name: 'core/heading',
-							attributes: {},
-							innerBlocks: [],
-						},
-					},
+					byClientId: new Map(
+						Object.entries( {
+							23: { clientId: '23', name: 'core/heading' },
+							123: { clientId: '123', name: 'core/paragraph' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							23: {},
+							123: {},
+						} )
+					),
+					order: new Map(
+						Object.entries( {
+							'': [ '23', '123' ],
+							23: [],
+							123: [],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							123: '',
+							23: '',
+						} )
+					),
+					tree: new Map(
+						Object.entries( {
+							23: {
+								clientId: '23',
+								name: 'core/heading',
+								attributes: {},
+								innerBlocks: [],
+							},
+						} )
+					),
 					controlledInnerBlocks: {},
 				},
 				selection: {
-					selectionStart: { clientId: 23 },
-					selectionEnd: { clientId: 23 },
+					selectionStart: { clientId: '23' },
+					selectionEnd: { clientId: '23' },
 				},
 			};
 
 			expect( getSelectedBlock( state ) ).toEqual(
-				getBlock( state, 23 )
+				getBlock( state, '23' )
 			);
 		} );
 	} );
@@ -1060,8 +1235,8 @@ describe( 'selectors', () => {
 		it( 'should return null if the block does not exist', () => {
 			const state = {
 				blocks: {
-					order: {},
-					parents: {},
+					order: new Map(),
+					parents: new Map(),
 				},
 			};
 
@@ -1071,20 +1246,24 @@ describe( 'selectors', () => {
 		it( 'should return root ClientId relative the block ClientId', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 123, 23 ],
-						123: [ 456, 56 ],
-					},
-					parents: {
-						123: '',
-						23: '',
-						456: 123,
-						56: 123,
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '123', '23' ],
+							123: [ '456', '56' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							123: '',
+							23: '',
+							456: '123',
+							56: '123',
+						} )
+					),
 				},
 			};
 
-			expect( getBlockRootClientId( state, 56 ) ).toBe( 123 );
+			expect( getBlockRootClientId( state, '56' ) ).toBe( '123' );
 		} );
 	} );
 
@@ -1092,8 +1271,8 @@ describe( 'selectors', () => {
 		it( 'should return the given block if the block has no parents', () => {
 			const state = {
 				blocks: {
-					order: {},
-					parents: {},
+					order: new Map(),
+					parents: new Map(),
 				},
 			};
 
@@ -1103,16 +1282,20 @@ describe( 'selectors', () => {
 		it( 'should return root ClientId relative the block ClientId', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 'a', 'b' ],
-						a: [ 'c', 'd' ],
-					},
-					parents: {
-						a: '',
-						b: '',
-						c: 'a',
-						d: 'a',
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ 'a', 'b' ],
+							a: [ 'c', 'd' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							a: '',
+							b: '',
+							c: 'a',
+							d: 'a',
+						} )
+					),
 				},
 			};
 
@@ -1122,18 +1305,22 @@ describe( 'selectors', () => {
 		it( 'should return the top level root ClientId relative the block ClientId', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 'a', 'b' ],
-						a: [ 'c', 'd' ],
-						d: [ 'e' ],
-					},
-					parents: {
-						a: '',
-						b: '',
-						c: 'a',
-						d: 'a',
-						e: 'd',
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ 'a', 'b' ],
+							a: [ 'c', 'd' ],
+							d: [ 'e' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							a: '',
+							b: '',
+							c: 'a',
+							d: 'a',
+							e: 'd',
+						} )
+					),
 				},
 			};
 
@@ -1145,13 +1332,17 @@ describe( 'selectors', () => {
 		it( 'should return empty if there is no selection', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 123, 23 ],
-					},
-					parents: {
-						123: '',
-						23: '',
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '123', '23' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							123: '',
+							23: '',
+						} )
+					),
 				},
 				selection: {
 					selectionStart: {},
@@ -1165,75 +1356,95 @@ describe( 'selectors', () => {
 		it( 'should return the selected block clientId if there is a selection', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 5, 4, 3, 2, 1 ],
-					},
-					parents: {
-						1: '',
-						2: '',
-						3: '',
-						4: '',
-						5: '',
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '5', '4', '3', '2', '1' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							1: '',
+							2: '',
+							3: '',
+							4: '',
+							5: '',
+						} )
+					),
 				},
 				selection: {
-					selectionStart: { clientId: 2 },
-					selectionEnd: { clientId: 2 },
+					selectionStart: { clientId: '2' },
+					selectionEnd: { clientId: '2' },
 				},
 			};
 
-			expect( getSelectedBlockClientIds( state ) ).toEqual( [ 2 ] );
+			expect( getSelectedBlockClientIds( state ) ).toEqual( [ '2' ] );
 		} );
 
 		it( 'should return selected block clientIds if there is multi selection', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 5, 4, 3, 2, 1 ],
-					},
-					parents: {
-						1: '',
-						2: '',
-						3: '',
-						4: '',
-						5: '',
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '5', '4', '3', '2', '1' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							1: '',
+							2: '',
+							3: '',
+							4: '',
+							5: '',
+						} )
+					),
 				},
 				selection: {
-					selectionStart: { clientId: 2 },
-					selectionEnd: { clientId: 4 },
+					selectionStart: { clientId: '2' },
+					selectionEnd: { clientId: '4' },
 				},
 			};
 
-			expect( getSelectedBlockClientIds( state ) ).toEqual( [ 4, 3, 2 ] );
+			expect( getSelectedBlockClientIds( state ) ).toEqual( [
+				'4',
+				'3',
+				'2',
+			] );
 		} );
 
 		it( 'should return selected block clientIds if there is multi selection (nested context)', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 5, 4, 3, 2, 1 ],
-						4: [ 9, 8, 7, 6 ],
-					},
-					parents: {
-						1: '',
-						2: '',
-						3: '',
-						4: '',
-						5: '',
-						6: 4,
-						7: 4,
-						8: 4,
-						9: 4,
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '5', '4', '3', '2', '1' ],
+							4: [ '9', '8', '7', '6' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							1: '',
+							2: '',
+							3: '',
+							4: '',
+							5: '',
+							6: '4',
+							7: '4',
+							8: '4',
+							9: '4',
+						} )
+					),
 				},
 				selection: {
-					selectionStart: { clientId: 7 },
-					selectionEnd: { clientId: 9 },
+					selectionStart: { clientId: '7' },
+					selectionEnd: { clientId: '9' },
 				},
 			};
 
-			expect( getSelectedBlockClientIds( state ) ).toEqual( [ 9, 8, 7 ] );
+			expect( getSelectedBlockClientIds( state ) ).toEqual( [
+				'9',
+				'8',
+				'7',
+			] );
 		} );
 	} );
 
@@ -1241,13 +1452,17 @@ describe( 'selectors', () => {
 		it( 'should return empty if there is no multi selection', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 123, 23 ],
-					},
-					parents: {
-						23: '',
-						123: '',
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '123', '23' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							23: '',
+							123: '',
+						} )
+					),
 				},
 				selection: {
 					selectionStart: {},
@@ -1261,55 +1476,67 @@ describe( 'selectors', () => {
 		it( 'should return selected block clientIds if there is multi selection', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 5, 4, 3, 2, 1 ],
-					},
-					parents: {
-						1: '',
-						2: '',
-						3: '',
-						4: '',
-						5: '',
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '5', '4', '3', '2', '1' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							1: '',
+							2: '',
+							3: '',
+							4: '',
+							5: '',
+						} )
+					),
 				},
 				selection: {
-					selectionStart: { clientId: 2 },
-					selectionEnd: { clientId: 4 },
+					selectionStart: { clientId: '2' },
+					selectionEnd: { clientId: '4' },
 				},
 			};
 
 			expect( getMultiSelectedBlockClientIds( state ) ).toEqual( [
-				4, 3, 2,
+				'4',
+				'3',
+				'2',
 			] );
 		} );
 
 		it( 'should return selected block clientIds if there is multi selection (nested context)', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 5, 4, 3, 2, 1 ],
-						4: [ 9, 8, 7, 6 ],
-					},
-					parents: {
-						1: '',
-						2: '',
-						3: '',
-						4: '',
-						5: '',
-						6: 4,
-						7: 4,
-						8: 4,
-						9: 4,
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '5', '4', '3', '2', '1' ],
+							4: [ '9', '8', '7', '6' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							1: '',
+							2: '',
+							3: '',
+							4: '',
+							5: '',
+							6: '4',
+							7: '4',
+							8: '4',
+							9: '4',
+						} )
+					),
 				},
 				selection: {
-					selectionStart: { clientId: 7 },
-					selectionEnd: { clientId: 9 },
+					selectionStart: { clientId: '7' },
+					selectionEnd: { clientId: '9' },
 				},
 			};
 
 			expect( getMultiSelectedBlockClientIds( state ) ).toEqual( [
-				9, 8, 7,
+				'9',
+				'8',
+				'7',
 			] );
 		} );
 	} );
@@ -1318,10 +1545,10 @@ describe( 'selectors', () => {
 		it( 'should return the same reference on subsequent invocations of empty selection', () => {
 			const state = {
 				blocks: {
-					byClientId: {},
-					attributes: {},
-					order: {},
-					parents: {},
+					byClientId: new Map(),
+					attributes: new Map(),
+					order: new Map(),
+					parents: new Map(),
 				},
 				selection: {
 					selectionStart: {},
@@ -1350,12 +1577,12 @@ describe( 'selectors', () => {
 		it( 'returns multi selection start', () => {
 			const state = {
 				selection: {
-					selectionStart: { clientId: 2 },
-					selectionEnd: { clientId: 4 },
+					selectionStart: { clientId: '2' },
+					selectionEnd: { clientId: '4' },
 				},
 			};
 
-			expect( getMultiSelectedBlocksStartClientId( state ) ).toBe( 2 );
+			expect( getMultiSelectedBlocksStartClientId( state ) ).toBe( '2' );
 		} );
 	} );
 
@@ -1374,12 +1601,12 @@ describe( 'selectors', () => {
 		it( 'returns multi selection end', () => {
 			const state = {
 				selection: {
-					selectionStart: { clientId: 2 },
-					selectionEnd: { clientId: 4 },
+					selectionStart: { clientId: '2' },
+					selectionEnd: { clientId: '4' },
 				},
 			};
 
-			expect( getMultiSelectedBlocksEndClientId( state ) ).toBe( 4 );
+			expect( getMultiSelectedBlocksEndClientId( state ) ).toBe( '4' );
 		} );
 	} );
 
@@ -1387,35 +1614,43 @@ describe( 'selectors', () => {
 		it( 'should return the ordered block ClientIds of top-level blocks by default', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 123, 23 ],
-					},
-					parents: {
-						23: '',
-						123: '',
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '123', '23' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							23: '',
+							123: '',
+						} )
+					),
 				},
 			};
 
-			expect( getBlockOrder( state ) ).toEqual( [ 123, 23 ] );
+			expect( getBlockOrder( state ) ).toEqual( [ '123', '23' ] );
 		} );
 
 		it( 'should return the ordered block ClientIds at a specified rootClientId', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 123, 23 ],
-						123: [ 456 ],
-					},
-					parents: {
-						23: '',
-						123: '',
-						456: 123,
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '123', '23' ],
+							123: [ '456' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							23: '',
+							123: '',
+							456: '123',
+						} )
+					),
 				},
 			};
 
-			expect( getBlockOrder( state, '123' ) ).toEqual( [ 456 ] );
+			expect( getBlockOrder( state, '123' ) ).toEqual( [ '456' ] );
 		} );
 	} );
 
@@ -1423,36 +1658,44 @@ describe( 'selectors', () => {
 		it( 'should return the block order', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 123, 23 ],
-					},
-					parents: {
-						23: '',
-						123: '',
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '123', '23' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							23: '',
+							123: '',
+						} )
+					),
 				},
 			};
 
-			expect( getBlockIndex( state, 23 ) ).toBe( 1 );
+			expect( getBlockIndex( state, '23' ) ).toBe( 1 );
 		} );
 
 		it( 'should return the block order (nested context)', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 123, 23 ],
-						123: [ 456, 56 ],
-					},
-					parents: {
-						23: '',
-						123: '',
-						56: 123,
-						456: 123,
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '123', '23' ],
+							123: [ '456', '56' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							23: '',
+							123: '',
+							56: '123',
+							456: '123',
+						} )
+					),
 				},
 			};
 
-			expect( getBlockIndex( state, 56 ) ).toBe( 1 );
+			expect( getBlockIndex( state, '56' ) ).toBe( 1 );
 		} );
 	} );
 
@@ -1460,73 +1703,91 @@ describe( 'selectors', () => {
 		it( 'should return the previous block', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 123, 23 ],
-					},
-					parents: {
-						23: '',
-						123: '',
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '123', '23' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							23: '',
+							123: '',
+						} )
+					),
 				},
 			};
 
-			expect( getPreviousBlockClientId( state, 23 ) ).toEqual( 123 );
+			expect( getPreviousBlockClientId( state, '23' ) ).toEqual( '123' );
 		} );
 
 		it( 'should return the previous block (nested context)', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 123, 23 ],
-						123: [ 456, 56 ],
-					},
-					parents: {
-						23: '',
-						123: '',
-						456: 123,
-						56: 123,
-					},
-				},
-			};
-
-			expect( getPreviousBlockClientId( state, 56, '123' ) ).toEqual(
-				456
+					order: new Map(
+						Object.entries( {
+							'': [ '123', '23' ],
+							123: [ '456', '56' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							23: '',
+							123: '',
+							456: '123',
+							56: '123',
+						} )
+					),
+				},
+			};
+
+			expect( getPreviousBlockClientId( state, '56', '123' ) ).toEqual(
+				'456'
 			);
 		} );
 
 		it( 'should return null for the first block', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 123, 23 ],
-					},
-					parents: {
-						23: '',
-						123: '',
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '123', '23' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							23: '',
+							123: '',
+						} )
+					),
 				},
 			};
 
-			expect( getPreviousBlockClientId( state, 123 ) ).toBeNull();
+			expect( getPreviousBlockClientId( state, '123' ) ).toBeNull();
 		} );
 
 		it( 'should return null for the first block (nested context)', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 123, 23 ],
-						123: [ 456, 56 ],
-					},
-					parents: {
-						23: '',
-						123: '',
-						456: 123,
-						56: 123,
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '123', '23' ],
+							123: [ '456', '56' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							23: '',
+							123: '',
+							456: '123',
+							56: '123',
+						} )
+					),
 				},
 			};
 
-			expect( getPreviousBlockClientId( state, 456, '123' ) ).toBeNull();
+			expect(
+				getPreviousBlockClientId( state, '456', '123' )
+			).toBeNull();
 		} );
 	} );
 
@@ -1534,71 +1795,89 @@ describe( 'selectors', () => {
 		it( 'should return the following block', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 123, 23 ],
-					},
-					parents: {
-						23: '',
-						123: '',
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '123', '23' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							23: '',
+							123: '',
+						} )
+					),
 				},
 			};
 
-			expect( getNextBlockClientId( state, 123 ) ).toEqual( 23 );
+			expect( getNextBlockClientId( state, '123' ) ).toEqual( '23' );
 		} );
 
 		it( 'should return the following block (nested context)', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 123, 23 ],
-						123: [ 456, 56 ],
-					},
-					parents: {
-						23: '',
-						123: '',
-						456: 123,
-						56: 123,
-					},
-				},
-			};
-
-			expect( getNextBlockClientId( state, 456, '123' ) ).toEqual( 56 );
+					order: new Map(
+						Object.entries( {
+							'': [ '123', '23' ],
+							123: [ '456', '56' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							23: '',
+							123: '',
+							456: '123',
+							56: '123',
+						} )
+					),
+				},
+			};
+
+			expect( getNextBlockClientId( state, '456', '123' ) ).toEqual(
+				'56'
+			);
 		} );
 
 		it( 'should return null for the last block', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 123, 23 ],
-					},
-					parents: {
-						23: '',
-						123: '',
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '123', '23' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							23: '',
+							123: '',
+						} )
+					),
 				},
 			};
 
-			expect( getNextBlockClientId( state, 23 ) ).toBeNull();
+			expect( getNextBlockClientId( state, '23' ) ).toBeNull();
 		} );
 
 		it( 'should return null for the last block (nested context)', () => {
 			const state = {
 				blocks: {
-					order: {
-						'': [ 123, 23 ],
-						123: [ 456, 56 ],
-					},
-					parents: {
-						23: '',
-						123: '',
-						456: 123,
-						56: 123,
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '123', '23' ],
+							123: [ '456', '56' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							23: '',
+							123: '',
+							456: '123',
+							56: '123',
+						} )
+					),
 				},
 			};
 
-			expect( getNextBlockClientId( state, 56, '123' ) ).toBeNull();
+			expect( getNextBlockClientId( state, '56', '123' ) ).toBeNull();
 		} );
 	} );
 
@@ -1606,23 +1885,23 @@ describe( 'selectors', () => {
 		it( 'should return true if the block is selected', () => {
 			const state = {
 				selection: {
-					selectionStart: { clientId: 123 },
-					selectionEnd: { clientId: 123 },
+					selectionStart: { clientId: '123' },
+					selectionEnd: { clientId: '123' },
 				},
 			};
 
-			expect( isBlockSelected( state, 123 ) ).toBe( true );
+			expect( isBlockSelected( state, '123' ) ).toBe( true );
 		} );
 
 		it( 'should return false if a multi-selection range exists', () => {
 			const state = {
 				selection: {
-					selectionStart: { clientId: 123 },
-					selectionEnd: { clientId: 124 },
+					selectionStart: { clientId: '123' },
+					selectionEnd: { clientId: '124' },
 				},
 			};
 
-			expect( isBlockSelected( state, 123 ) ).toBe( false );
+			expect( isBlockSelected( state, '123' ) ).toBe( false );
 		} );
 
 		it( 'should return false if the block is not selected', () => {
@@ -1633,7 +1912,7 @@ describe( 'selectors', () => {
 				},
 			};
 
-			expect( isBlockSelected( state, 23 ) ).toBe( false );
+			expect( isBlockSelected( state, '23' ) ).toBe( false );
 		} );
 	} );
 
@@ -1641,87 +1920,103 @@ describe( 'selectors', () => {
 		it( 'should return false if the selected block is a child of the given ClientId', () => {
 			const state = {
 				selection: {
-					selectionStart: { clientId: 5 },
-					selectionEnd: { clientId: 5 },
+					selectionStart: { clientId: '5' },
+					selectionEnd: { clientId: '5' },
 				},
 				blocks: {
-					order: {
-						4: [ 3, 2, 1 ],
-					},
-					parents: {
-						1: 4,
-						2: 4,
-						3: 4,
-					},
+					order: new Map(
+						Object.entries( {
+							4: [ '3', '2', '1' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							1: '4',
+							2: '4',
+							3: '4',
+						} )
+					),
 				},
 			};
 
-			expect( hasSelectedInnerBlock( state, 4 ) ).toBe( false );
+			expect( hasSelectedInnerBlock( state, '4' ) ).toBe( false );
 		} );
 
 		it( 'should return true if the selected block is a child of the given ClientId', () => {
 			const state = {
 				selection: {
-					selectionStart: { clientId: 3 },
-					selectionEnd: { clientId: 3 },
+					selectionStart: { clientId: '3' },
+					selectionEnd: { clientId: '3' },
 				},
 				blocks: {
-					order: {
-						4: [ 3, 2, 1 ],
-					},
-					parents: {
-						1: 4,
-						2: 4,
-						3: 4,
-					},
+					order: new Map(
+						Object.entries( {
+							4: [ '3', '2', '1' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							1: '4',
+							2: '4',
+							3: '4',
+						} )
+					),
 				},
 			};
 
-			expect( hasSelectedInnerBlock( state, 4 ) ).toBe( true );
+			expect( hasSelectedInnerBlock( state, '4' ) ).toBe( true );
 		} );
 
 		it( 'should return true if a multi selection exists that contains children of the block with the given ClientId', () => {
 			const state = {
 				blocks: {
-					order: {
-						6: [ 5, 4, 3, 2, 1 ],
-					},
-					parents: {
-						1: 6,
-						2: 6,
-						3: 6,
-						4: 6,
-						5: 6,
-					},
+					order: new Map(
+						Object.entries( {
+							6: [ '5', '4', '3', '2', '1' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							1: '6',
+							2: '6',
+							3: '6',
+							4: '6',
+							5: '6',
+						} )
+					),
 				},
 				selection: {
-					selectionStart: { clientId: 2 },
-					selectionEnd: { clientId: 4 },
+					selectionStart: { clientId: '2' },
+					selectionEnd: { clientId: '4' },
 				},
 			};
-			expect( hasSelectedInnerBlock( state, 6 ) ).toBe( true );
+			expect( hasSelectedInnerBlock( state, '6' ) ).toBe( true );
 		} );
 
 		it( 'should return false if a multi selection exists bot does not contains children of the block with the given ClientId', () => {
 			const state = {
-				blocks: {
-					order: {
-						3: [ 2, 1 ],
-						6: [ 5, 4 ],
-					},
-					parents: {
-						1: 3,
-						2: 3,
-						4: 6,
-						5: 6,
-					},
+				blocks: {
+					order: new Map(
+						Object.entries( {
+							3: [ '2', '1' ],
+							6: [ '5', '4' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							1: '3',
+							2: '3',
+							4: '6',
+							5: '6',
+						} )
+					),
 				},
 				selection: {
-					selectionStart: { clientId: 5 },
-					selectionEnd: { clientId: 4 },
+					selectionStart: { clientId: '5' },
+					selectionEnd: { clientId: '4' },
 				},
 			};
-			expect( hasSelectedInnerBlock( state, 3 ) ).toBe( false );
+			expect( hasSelectedInnerBlock( state, '3' ) ).toBe( false );
 		} );
 	} );
 
@@ -1729,70 +2024,82 @@ describe( 'selectors', () => {
 		it( 'should return true if the block is selected but not the last', () => {
 			const state = {
 				selection: {
-					selectionStart: { clientId: 5 },
-					selectionEnd: { clientId: 3 },
+					selectionStart: { clientId: '5' },
+					selectionEnd: { clientId: '3' },
 				},
 				blocks: {
-					order: {
-						'': [ 5, 4, 3, 2, 1 ],
-					},
-					parents: {
-						1: '',
-						2: '',
-						3: '',
-						4: '',
-						5: '',
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '5', '4', '3', '2', '1' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							1: '',
+							2: '',
+							3: '',
+							4: '',
+							5: '',
+						} )
+					),
 				},
 			};
 
-			expect( isBlockWithinSelection( state, 4 ) ).toBe( true );
+			expect( isBlockWithinSelection( state, '4' ) ).toBe( true );
 		} );
 
 		it( 'should return false if the block is the last selected', () => {
 			const state = {
 				selection: {
-					selectionStart: { clientId: 5 },
-					selectionEnd: { clientId: 3 },
+					selectionStart: { clientId: '5' },
+					selectionEnd: { clientId: '3' },
 				},
 				blocks: {
-					order: {
-						'': [ 5, 4, 3, 2, 1 ],
-					},
-					parents: {
-						1: '',
-						2: '',
-						3: '',
-						4: '',
-						5: '',
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '5', '4', '3', '2', '1' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							1: '',
+							2: '',
+							3: '',
+							4: '',
+							5: '',
+						} )
+					),
 				},
 			};
 
-			expect( isBlockWithinSelection( state, 3 ) ).toBe( false );
+			expect( isBlockWithinSelection( state, '3' ) ).toBe( false );
 		} );
 
 		it( 'should return false if the block is not selected', () => {
 			const state = {
 				selection: {
-					selectionStart: { clientId: 5 },
-					selectionEnd: { clientId: 3 },
+					selectionStart: { clientId: '5' },
+					selectionEnd: { clientId: '3' },
 				},
 				blocks: {
-					order: {
-						'': [ 5, 4, 3, 2, 1 ],
-					},
-					parents: {
-						1: '',
-						2: '',
-						3: '',
-						4: '',
-						5: '',
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '5', '4', '3', '2', '1' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							1: '',
+							2: '',
+							3: '',
+							4: '',
+							5: '',
+						} )
+					),
 				},
 			};
 
-			expect( isBlockWithinSelection( state, 2 ) ).toBe( false );
+			expect( isBlockWithinSelection( state, '2' ) ).toBe( false );
 		} );
 
 		it( 'should return false if there is no selection', () => {
@@ -1802,20 +2109,24 @@ describe( 'selectors', () => {
 					selectionEnd: {},
 				},
 				blocks: {
-					order: {
-						'': [ 5, 4, 3, 2, 1 ],
-					},
-					parents: {
-						1: '',
-						2: '',
-						3: '',
-						4: '',
-						5: '',
-					},
+					order: new Map(
+						Object.entries( {
+							'': [ '5', '4', '3', '2', '1' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							1: '',
+							2: '',
+							3: '',
+							4: '',
+							5: '',
+						} )
+					),
 				},
 			};
 
-			expect( isBlockWithinSelection( state, 4 ) ).toBe( false );
+			expect( isBlockWithinSelection( state, '4' ) ).toBe( false );
 		} );
 	} );
 
@@ -1865,58 +2176,66 @@ describe( 'selectors', () => {
 	describe( 'isBlockMultiSelected', () => {
 		const state = {
 			blocks: {
-				order: {
-					'': [ 5, 4, 3, 2, 1 ],
-				},
-				parents: {
-					1: '',
-					2: '',
-					3: '',
-					4: '',
-					5: '',
-				},
+				order: new Map(
+					Object.entries( {
+						'': [ '5', '4', '3', '2', '1' ],
+					} )
+				),
+				parents: new Map(
+					Object.entries( {
+						1: '',
+						2: '',
+						3: '',
+						4: '',
+						5: '',
+					} )
+				),
 			},
 			selection: {
-				selectionStart: { clientId: 2 },
-				selectionEnd: { clientId: 4 },
+				selectionStart: { clientId: '2' },
+				selectionEnd: { clientId: '4' },
 			},
 		};
 
 		it( 'should return true if the block is multi selected', () => {
-			expect( isBlockMultiSelected( state, 3 ) ).toBe( true );
+			expect( isBlockMultiSelected( state, '3' ) ).toBe( true );
 		} );
 
 		it( 'should return false if the block is not multi selected', () => {
-			expect( isBlockMultiSelected( state, 5 ) ).toBe( false );
+			expect( isBlockMultiSelected( state, '5' ) ).toBe( false );
 		} );
 	} );
 
 	describe( 'isFirstMultiSelectedBlock', () => {
 		const state = {
 			blocks: {
-				order: {
-					'': [ 5, 4, 3, 2, 1 ],
-				},
-				parents: {
-					1: '',
-					2: '',
-					3: '',
-					4: '',
-					5: '',
-				},
+				order: new Map(
+					Object.entries( {
+						'': [ '5', '4', '3', '2', '1' ],
+					} )
+				),
+				parents: new Map(
+					Object.entries( {
+						1: '',
+						2: '',
+						3: '',
+						4: '',
+						5: '',
+					} )
+				),
 			},
 			selection: {
-				selectionStart: { clientId: 2 },
-				selectionEnd: { clientId: 4 },
+				selectionStart: { clientId: '2' },
+				selectionEnd: { clientId: '4' },
 			},
 		};
 
 		it( 'should return true if the block is first in multi selection', () => {
-			expect( isFirstMultiSelectedBlock( state, 4 ) ).toBe( true );
+			expect( isFirstMultiSelectedBlock( state, '4' ) ).toBe( true );
 		} );
 
 		it( 'should return false if the block is not first in multi selection', () => {
-			expect( isFirstMultiSelectedBlock( state, 3 ) ).toBe( false );
+			expect( isFirstMultiSelectedBlock( state, '3' ) ).toBe( false );
 		} );
 	} );
 
@@ -1926,7 +2245,7 @@ describe( 'selectors', () => {
 				blocksMode: {},
 			};
 
-			expect( getBlockMode( state, 123 ) ).toEqual( 'visual' );
+			expect( getBlockMode( state, '123' ) ).toEqual( 'visual' );
 		} );
 
 		it( 'should return the block mode', () => {
@@ -1936,7 +2255,25 @@ describe( 'selectors', () => {
 				},
 			};
 
-			expect( getBlockMode( state, 123 ) ).toEqual( 'html' );
+			expect( getBlockMode( state, '123' ) ).toEqual( 'html' );
+		} );
+	} );
+
+	describe( 'isBlockInterfaceHidden', () => {
+		it( 'should return the true if toggled true in state', () => {
+			const state = {
+				isBlockInterfaceHidden: true,
+			};
+
+			expect( isBlockInterfaceHidden( state ) ).toBe( true );
+		} );
+
+		it( 'should return false if toggled false in state', () => {
+			const state = {
+				isBlockInterfaceHidden: false,
+			};
+
+			expect( isBlockInterfaceHidden( state ) ).toBe( false );
 		} );
 	} );
 
@@ -2012,10 +2349,12 @@ describe( 'selectors', () => {
 			const state = {
 				draggedBlocks: [ 'block-1_grandparent' ],
 				blocks: {
-					parents: {
-						'block-1': 'block-1_parent',
-						'block-1_parent': 'block-1_grandparent',
-					},
+					parents: new Map(
+						Object.entries( {
+							'block-1': 'block-1_parent',
+							'block-1_parent': 'block-1_grandparent',
+						} )
+					),
 				},
 			};
 			expect( isAncestorBeingDragged( state, 'block-1' ) ).toBe( true );
@@ -2025,10 +2364,12 @@ describe( 'selectors', () => {
 			const state = {
 				draggedBlocks: [ 'block-2_grandparent' ],
 				blocks: {
-					parents: {
-						'block-1': 'block-1_parent',
-						'block-1_parent': 'block-1_grandparent',
-					},
+					parents: new Map(
+						Object.entries( {
+							'block-1': 'block-1_parent',
+							'block-1_parent': 'block-1_grandparent',
+						} )
+					),
 				},
 			};
 			expect( isAncestorBeingDragged( state, 'block-1' ) ).toBe( false );
@@ -2038,10 +2379,12 @@ describe( 'selectors', () => {
 			const state = {
 				draggedBlocks: [],
 				blocks: {
-					parents: {
-						'block-1': 'block-1_parent',
-						'block-1_parent': 'block-1_grandparent',
-					},
+					parents: new Map(
+						Object.entries( {
+							'block-1': 'block-1_parent',
+							'block-1_parent': 'block-1_grandparent',
+						} )
+					),
 				},
 			};
 			expect( isAncestorBeingDragged( state, 'block-1' ) ).toBe( false );
@@ -2074,23 +2417,31 @@ describe( 'selectors', () => {
 					selectionEnd: { clientId: 'clientId2' },
 				},
 				blocks: {
-					byClientId: {
-						clientId1: { clientId: 'clientId1' },
-						clientId2: { clientId: 'clientId2' },
-					},
-					attributes: {
-						clientId1: {},
-						clientId2: {},
-					},
-					order: {
-						'': [ 'clientId1' ],
-						clientId1: [ 'clientId2' ],
-						clientId2: [],
-					},
-					parents: {
-						clientId1: '',
-						clientId2: 'clientId1',
-					},
+					byClientId: new Map(
+						Object.entries( {
+							clientId1: { clientId: 'clientId1' },
+							clientId2: { clientId: 'clientId2' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							clientId1: {},
+							clientId2: {},
+						} )
+					),
+					order: new Map(
+						Object.entries( {
+							'': [ 'clientId1' ],
+							clientId1: [ 'clientId2' ],
+							clientId2: [],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							clientId1: '',
+							clientId2: 'clientId1',
+						} )
+					),
 				},
 				insertionPoint: {
 					rootClientId: undefined,
@@ -2111,19 +2462,27 @@ describe( 'selectors', () => {
 					selectionEnd: { clientId: 'clientId1' },
 				},
 				blocks: {
-					byClientId: {
-						clientId1: { clientId: 'clientId1' },
-					},
-					attributes: {
-						clientId1: {},
-					},
-					order: {
-						'': [ 'clientId1' ],
-						clientId1: [],
-					},
-					parents: {
-						clientId1: '',
-					},
+					byClientId: new Map(
+						Object.entries( {
+							clientId1: { clientId: 'clientId1' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							clientId1: {},
+						} )
+					),
+					order: new Map(
+						Object.entries( {
+							'': [ 'clientId1' ],
+							clientId1: [],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							clientId1: '',
+						} )
+					),
 				},
 				insertionPoint: null,
 			};
@@ -2141,23 +2500,31 @@ describe( 'selectors', () => {
 					selectionEnd: { clientId: 'clientId2' },
 				},
 				blocks: {
-					byClientId: {
-						clientId1: { clientId: 'clientId1' },
-						clientId2: { clientId: 'clientId2' },
-					},
-					attributes: {
-						clientId1: {},
-						clientId2: {},
-					},
-					order: {
-						'': [ 'clientId1' ],
-						clientId1: [ 'clientId2' ],
-						clientId2: [],
-					},
-					parents: {
-						clientId1: '',
-						clientId2: 'clientId1',
-					},
+					byClientId: new Map(
+						Object.entries( {
+							clientId1: { clientId: 'clientId1' },
+							clientId2: { clientId: 'clientId2' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							clientId1: {},
+							clientId2: {},
+						} )
+					),
+					order: new Map(
+						Object.entries( {
+							'': [ 'clientId1' ],
+							clientId1: [ 'clientId2' ],
+							clientId2: [],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							clientId1: '',
+							clientId2: 'clientId1',
+						} )
+					),
 				},
 				insertionPoint: null,
 			};
@@ -2175,23 +2542,31 @@ describe( 'selectors', () => {
 					selectionEnd: { clientId: 'clientId2' },
 				},
 				blocks: {
-					byClientId: {
-						clientId1: { clientId: 'clientId1' },
-						clientId2: { clientId: 'clientId2' },
-					},
-					attributes: {
-						clientId1: {},
-						clientId2: {},
-					},
-					order: {
-						'': [ 'clientId1', 'clientId2' ],
-						clientId1: [],
-						clientId2: [],
-					},
-					parents: {
-						clientId1: '',
-						clientId2: '',
-					},
+					byClientId: new Map(
+						Object.entries( {
+							clientId1: { clientId: 'clientId1' },
+							clientId2: { clientId: 'clientId2' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							clientId1: {},
+							clientId2: {},
+						} )
+					),
+					order: new Map(
+						Object.entries( {
+							'': [ 'clientId1', 'clientId2' ],
+							clientId1: [],
+							clientId2: [],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							clientId1: '',
+							clientId2: '',
+						} )
+					),
 				},
 				insertionPoint: null,
 			};
@@ -2209,23 +2584,31 @@ describe( 'selectors', () => {
 					selectionEnd: {},
 				},
 				blocks: {
-					byClientId: {
-						clientId1: { clientId: 'clientId1' },
-						clientId2: { clientId: 'clientId2' },
-					},
-					attributes: {
-						clientId1: {},
-						clientId2: {},
-					},
-					order: {
-						'': [ 'clientId1', 'clientId2' ],
-						clientId1: [],
-						clientId2: [],
-					},
-					parents: {
-						clientId1: '',
-						clientId2: '',
-					},
+					byClientId: new Map(
+						Object.entries( {
+							clientId1: { clientId: 'clientId1' },
+							clientId2: { clientId: 'clientId2' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							clientId1: {},
+							clientId2: {},
+						} )
+					),
+					order: new Map(
+						Object.entries( {
+							'': [ 'clientId1', 'clientId2' ],
+							clientId1: [],
+							clientId2: [],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							clientId1: '',
+							clientId2: '',
+						} )
+					),
 				},
 				insertionPoint: null,
 			};
@@ -2262,8 +2645,8 @@ describe( 'selectors', () => {
 		it( 'should deny blocks that are not registered', () => {
 			const state = {
 				blocks: {
-					byClientId: {},
-					attributes: {},
+					byClientId: new Map(),
+					attributes: new Map(),
 				},
 				blockListSettings: {},
 				settings: {},
@@ -2274,8 +2657,8 @@ describe( 'selectors', () => {
 		it( 'should deny blocks that are not allowed by the editor', () => {
 			const state = {
 				blocks: {
-					byClientId: {},
-					attributes: {},
+					byClientId: new Map(),
+					attributes: new Map(),
 				},
 				blockListSettings: {},
 				settings: {
@@ -2290,8 +2673,8 @@ describe( 'selectors', () => {
 		it( 'should allow blocks that are allowed by the editor', () => {
 			const state = {
 				blocks: {
-					byClientId: {},
-					attributes: {},
+					byClientId: new Map(),
+					attributes: new Map(),
 				},
 				blockListSettings: {},
 				settings: {
@@ -2306,8 +2689,8 @@ describe( 'selectors', () => {
 		it( 'should deny blocks when the editor has a template lock', () => {
 			const state = {
 				blocks: {
-					byClientId: {},
-					attributes: {},
+					byClientId: new Map(),
+					attributes: new Map(),
 				},
 				blockListSettings: {},
 				settings: {
@@ -2322,8 +2705,8 @@ describe( 'selectors', () => {
 		it( 'should deny blocks that restrict parent from being inserted into the root', () => {
 			const state = {
 				blocks: {
-					byClientId: {},
-					attributes: {},
+					byClientId: new Map(),
+					attributes: new Map(),
 				},
 				blockListSettings: {},
 				settings: {},
@@ -2336,12 +2719,16 @@ describe( 'selectors', () => {
 		it( 'should deny blocks that restrict parent from being inserted into a restricted parent', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						block1: { name: 'core/test-block-a' },
-					},
-					attributes: {
-						block1: {},
-					},
+					byClientId: new Map(
+						Object.entries( {
+							block1: { name: 'core/test-block-a' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							block1: {},
+						} )
+					),
 				},
 				blockListSettings: {},
 				settings: {},
@@ -2354,12 +2741,16 @@ describe( 'selectors', () => {
 		it( 'should allow blocks to be inserted into an allowed parent', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						block1: { name: 'core/test-block-b' },
-					},
-					attributes: {
-						block1: {},
-					},
+					byClientId: new Map(
+						Object.entries( {
+							block1: { name: 'core/test-block-b' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							block1: {},
+						} )
+					),
 				},
 				blockListSettings: {
 					block1: {},
@@ -2374,12 +2765,16 @@ describe( 'selectors', () => {
 		it( 'should deny blocks from being inserted into a block that does not allow inner blocks', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						block1: { name: 'core/test-block-b' },
-					},
-					attributes: {
-						block1: {},
-					},
+					byClientId: new Map(
+						Object.entries( {
+							block1: { name: 'core/test-block-b' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							block1: {},
+						} )
+					),
 				},
 				blockListSettings: {
 					block1: {},
@@ -2394,12 +2789,16 @@ describe( 'selectors', () => {
 		it( 'should deny restricted blocks from being inserted into a block that restricts allowedBlocks', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						block1: { name: 'core/test-block-a' },
-					},
-					attributes: {
-						block1: {},
-					},
+					byClientId: new Map(
+						Object.entries( {
+							block1: { name: 'core/test-block-a' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							block1: {},
+						} )
+					),
 				},
 				blockListSettings: {
 					block1: {
@@ -2416,12 +2815,16 @@ describe( 'selectors', () => {
 		it( 'should allow allowed blocks to be inserted into a block that restricts allowedBlocks', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						block1: { name: 'core/test-block-a' },
-					},
-					attributes: {
-						block1: {},
-					},
+					byClientId: new Map(
+						Object.entries( {
+							block1: { name: 'core/test-block-a' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							block1: {},
+						} )
+					),
 				},
 				blockListSettings: {
 					block1: {
@@ -2438,12 +2841,16 @@ describe( 'selectors', () => {
 		it( 'should prioritise parent over allowedBlocks', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						block1: { name: 'core/test-block-b' },
-					},
-					attributes: {
-						block1: {},
-					},
+					byClientId: new Map(
+						Object.entries( {
+							block1: { name: 'core/test-block-b' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							block1: {},
+						} )
+					),
 				},
 				blockListSettings: {
 					block1: {
@@ -2460,12 +2867,16 @@ describe( 'selectors', () => {
 		it( 'should deny blocks that restrict parent to core/post-content when not in editor root', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						block1: { name: 'core/test-block-c' },
-					},
-					attributes: {
-						block1: {},
-					},
+					byClientId: new Map(
+						Object.entries( {
+							block1: { name: 'core/test-block-c' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							block1: {},
+						} )
+					),
 				},
 				blockListSettings: {},
 				settings: {},
@@ -2478,8 +2889,8 @@ describe( 'selectors', () => {
 		it( 'should allow blocks that restrict parent to core/post-content when in editor root', () => {
 			const state = {
 				blocks: {
-					byClientId: {},
-					attributes: {},
+					byClientId: new Map(),
+					attributes: new Map(),
 				},
 				blockListSettings: {},
 				settings: {},
@@ -2492,17 +2903,23 @@ describe( 'selectors', () => {
 		it( 'should allow blocks to be inserted in a descendant of a required ancestor', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						block1: { name: 'core/test-block-ancestor' },
-						block2: { name: 'core/block' },
-					},
-					attributes: {
-						block1: {},
-						block2: {},
-					},
-					parents: {
-						block2: 'block1',
-					},
+					byClientId: new Map(
+						Object.entries( {
+							block1: { name: 'core/test-block-ancestor' },
+							block2: { name: 'core/block' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							block1: {},
+							block2: {},
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							block2: 'block1',
+						} )
+					),
 				},
 				blockListSettings: {
 					block1: {},
@@ -2522,20 +2939,26 @@ describe( 'selectors', () => {
 		it( 'should allow blocks to be inserted if both parent and ancestor restrictions are met', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						block1: { name: 'core/test-block-ancestor' },
-						block2: { name: 'core/block' },
-						block3: { name: 'core/test-block-parent' },
-					},
-					attributes: {
-						block1: {},
-						block2: {},
-						block3: {},
-					},
-					parents: {
-						block2: 'block1',
-						block3: 'block2',
-					},
+					byClientId: new Map(
+						Object.entries( {
+							block1: { name: 'core/test-block-ancestor' },
+							block2: { name: 'core/block' },
+							block3: { name: 'core/test-block-parent' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							block1: {},
+							block2: {},
+							block3: {},
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							block2: 'block1',
+							block3: 'block2',
+						} )
+					),
 				},
 				blockListSettings: {
 					block1: {},
@@ -2556,19 +2979,25 @@ describe( 'selectors', () => {
 		it( 'should deny blocks from being inserted outside a required ancestor', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						block1: { name: 'core/test-block-ancestor' },
-						block2: { name: 'core/block' },
-						block3: { name: 'core/block' },
-					},
-					attributes: {
-						block1: {},
-						block2: {},
-						block3: {},
-					},
-					parents: {
-						block3: 'block2',
-					},
+					byClientId: new Map(
+						Object.entries( {
+							block1: { name: 'core/test-block-ancestor' },
+							block2: { name: 'core/block' },
+							block3: { name: 'core/block' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							block1: {},
+							block2: {},
+							block3: {},
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							block3: 'block2',
+						} )
+					),
 				},
 				blockListSettings: {
 					block1: {},
@@ -2589,19 +3018,25 @@ describe( 'selectors', () => {
 		it( 'should deny blocks from being inserted outside of a required ancestor, even if parent matches', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						block1: { name: 'core/test-block-ancestor' },
-						block2: { name: 'core/block' },
-						block3: { name: 'core/test-block-parent' },
-					},
-					attributes: {
-						block1: {},
-						block2: {},
-						block3: {},
-					},
-					parents: {
-						block3: 'block2',
-					},
+					byClientId: new Map(
+						Object.entries( {
+							block1: { name: 'core/test-block-ancestor' },
+							block2: { name: 'core/block' },
+							block3: { name: 'core/test-block-parent' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							block1: {},
+							block2: {},
+							block3: {},
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							block3: 'block2',
+						} )
+					),
 				},
 				blockListSettings: {
 					block1: {},
@@ -2622,17 +3057,23 @@ describe( 'selectors', () => {
 		it( 'should deny blocks from being inserted inside ancestor if parent restricts allowedBlocks', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						block1: { name: 'core/test-block-ancestor' },
-						block2: { name: 'core/block' },
-					},
-					attributes: {
-						block1: {},
-						block2: {},
-					},
-					parents: {
-						block2: 'block1',
-					},
+					byClientId: new Map(
+						Object.entries( {
+							block1: { name: 'core/test-block-ancestor' },
+							block2: { name: 'core/block' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							block1: {},
+							block2: {},
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							block2: 'block1',
+						} )
+					),
 				},
 				blockListSettings: {
 					block1: {},
@@ -2654,17 +3095,23 @@ describe( 'selectors', () => {
 		it( 'should deny blocks from being inserted inside ancestor if parent restriction is not met', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						block1: { name: 'core/test-block-ancestor' },
-						block2: { name: 'core/block' },
-					},
-					attributes: {
-						block1: {},
-						block2: {},
-					},
-					parents: {
-						block2: 'block1',
-					},
+					byClientId: new Map(
+						Object.entries( {
+							block1: { name: 'core/test-block-ancestor' },
+							block2: { name: 'core/block' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							block1: {},
+							block2: {},
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							block2: 'block1',
+						} )
+					),
 				},
 				blockListSettings: {
 					block1: {},
@@ -2686,16 +3133,20 @@ describe( 'selectors', () => {
 		it( 'should allow blocks', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						1: { name: 'core/test-block-a' },
-						2: { name: 'core/test-block-b' },
-						3: { name: 'core/test-block-c' },
-					},
-					attributes: {
-						1: {},
-						2: {},
-						3: {},
-					},
+					byClientId: new Map(
+						Object.entries( {
+							1: { name: 'core/test-block-a' },
+							2: { name: 'core/test-block-b' },
+							3: { name: 'core/test-block-c' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							1: {},
+							2: {},
+							3: {},
+						} )
+					),
 				},
 				blockListSettings: {
 					1: {
@@ -2713,16 +3164,20 @@ describe( 'selectors', () => {
 		it( 'should deny blocks', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						1: { name: 'core/test-block-a' },
-						2: { name: 'core/test-block-b' },
-						3: { name: 'core/test-block-c' },
-					},
-					attributes: {
-						1: {},
-						2: {},
-						3: {},
-					},
+					byClientId: new Map(
+						Object.entries( {
+							1: { name: 'core/test-block-a' },
+							2: { name: 'core/test-block-b' },
+							3: { name: 'core/test-block-c' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							1: {},
+							2: {},
+							3: {},
+						} )
+					),
 				},
 				blockListSettings: {
 					1: {
@@ -2739,15 +3194,17 @@ describe( 'selectors', () => {
 		it( 'should properly list block type and reusable block items', () => {
 			const state = {
 				blocks: {
-					byClientId: {},
-					attributes: {},
-					order: {},
-					parents: {},
-					tree: {
-						'': {
-							innerBlocks: [],
-						},
-					},
+					byClientId: new Map(),
+					attributes: new Map(),
+					order: new Map(),
+					parents: new Map(),
+					tree: new Map(
+						Object.entries( {
+							'': {
+								innerBlocks: [],
+							},
+						} )
+					),
 				},
 				settings: {
 					__experimentalReusableBlocks: [
@@ -2808,35 +3265,45 @@ describe( 'selectors', () => {
 		it( 'should correctly cache the return values', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						block3: { name: 'core/test-block-a' },
-						block4: { name: 'core/test-block-a' },
-					},
-					attributes: {
-						block3: {},
-						block4: {},
-					},
-					order: {
-						'': [ 'block3', 'block4' ],
-					},
-					parents: {
-						block3: '',
-						block4: '',
-					},
-					tree: {
-						block3: {
-							clientId: 'block3',
-							name: 'core/test-block-a',
-							attributes: {},
-							innerBlocks: [],
-						},
-						block4: {
-							clientId: 'block4',
-							name: 'core/test-block-a',
-							attributes: {},
-							innerBlocks: [],
-						},
-					},
+					byClientId: new Map(
+						Object.entries( {
+							block3: { name: 'core/test-block-a' },
+							block4: { name: 'core/test-block-a' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							block3: {},
+							block4: {},
+						} )
+					),
+					order: new Map(
+						Object.entries( {
+							'': [ 'block3', 'block4' ],
+						} )
+					),
+					parents: new Map(
+						Object.entries( {
+							block3: '',
+							block4: '',
+						} )
+					),
+					tree: new Map(
+						Object.entries( {
+							block3: {
+								clientId: 'block3',
+								name: 'core/test-block-a',
+								attributes: {},
+								innerBlocks: [],
+							},
+							block4: {
+								clientId: 'block4',
+								name: 'core/test-block-a',
+								attributes: {},
+								innerBlocks: [],
+							},
+						} )
+					),
 					controlledInnerBlocks: {},
 				},
 				settings: {
@@ -2915,28 +3382,36 @@ describe( 'selectors', () => {
 		it( 'should set isDisabled when a block with `multiple: false` has been used', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						block1: {
-							clientId: 'block1',
-							name: 'core/test-block-b',
-						},
-					},
-					attributes: {
-						block1: { attribute: {} },
-					},
-					order: {
-						'': [ 'block1' ],
-					},
-					tree: {
-						block1: {
-							clientId: 'block1',
-							name: 'core/test-block-b',
-							attributes: {},
-							innerBlocks: [],
-						},
-					},
+					byClientId: new Map(
+						Object.entries( {
+							block1: {
+								clientId: 'block1',
+								name: 'core/test-block-b',
+							},
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							block1: { attribute: {} },
+						} )
+					),
+					order: new Map(
+						Object.entries( {
+							'': [ 'block1' ],
+						} )
+					),
+					tree: new Map(
+						Object.entries( {
+							block1: {
+								clientId: 'block1',
+								name: 'core/test-block-b',
+								attributes: {},
+								innerBlocks: [],
+							},
+						} )
+					),
 					controlledInnerBlocks: {},
-					parents: {},
+					parents: new Map(),
 				},
 				preferences: {
 					insertUsage: {},
@@ -2954,10 +3429,10 @@ describe( 'selectors', () => {
 		it( 'should set a frecency', () => {
 			const state = {
 				blocks: {
-					byClientId: {},
-					attributes: {},
-					order: {},
-					parents: {},
+					byClientId: new Map(),
+					attributes: new Map(),
+					order: new Map(),
+					parents: new Map(),
 					cache: {},
 				},
 				preferences: {
@@ -3049,10 +3524,10 @@ describe( 'selectors', () => {
 		it( 'should properly return block type items', () => {
 			const state = {
 				blocks: {
-					byClientId: {},
-					attributes: {},
-					order: {},
-					parents: {},
+					byClientId: new Map(),
+					attributes: new Map(),
+					order: new Map(),
+					parents: new Map(),
 					cache: {},
 				},
 				settings: {},
@@ -3089,10 +3564,10 @@ describe( 'selectors', () => {
 		it( 'should support single block object', () => {
 			const state = {
 				blocks: {
-					byClientId: {},
-					attributes: {},
-					order: {},
-					parents: {},
+					byClientId: new Map(),
+					attributes: new Map(),
+					order: new Map(),
+					parents: new Map(),
 					cache: {},
 				},
 				settings: {},
@@ -3106,19 +3581,25 @@ describe( 'selectors', () => {
 		it( 'should return only eligible blocks for transformation - `allowedBlocks`', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						block1: { name: 'core/with-tranforms-b' },
-						block2: { name: 'core/with-tranforms-a' },
-					},
-					attributes: {
-						block1: {},
-						block2: {},
-					},
-					order: {},
-					parents: {
-						block1: '',
-						block2: 'block1',
-					},
+					byClientId: new Map(
+						Object.entries( {
+							block1: { name: 'core/with-tranforms-b' },
+							block2: { name: 'core/with-tranforms-a' },
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							block1: {},
+							block2: {},
+						} )
+					),
+					order: new Map(),
+					parents: new Map(
+						Object.entries( {
+							block1: '',
+							block2: 'block1',
+						} )
+					),
 					cache: {},
 					controlledInnerBlocks: {},
 				},
@@ -3141,28 +3622,36 @@ describe( 'selectors', () => {
 		it( 'should take into account the usage of blocks settings `multiple` - if multiple blocks of the same type are allowed', () => {
 			const state = {
 				blocks: {
-					byClientId: {
-						block1: {
-							clientId: 'block1',
-							name: 'core/with-tranforms-c',
-						},
-					},
-					attributes: {
-						block1: { attribute: {} },
-					},
-					order: {
-						'': [ 'block1' ],
-					},
-					tree: {
-						block1: {
-							clientId: 'block1',
-							name: 'core/with-tranforms-c',
-							attributes: {},
-							innerBlocks: [],
-						},
-					},
+					byClientId: new Map(
+						Object.entries( {
+							block1: {
+								clientId: 'block1',
+								name: 'core/with-tranforms-c',
+							},
+						} )
+					),
+					attributes: new Map(
+						Object.entries( {
+							block1: { attribute: {} },
+						} )
+					),
+					order: new Map(
+						Object.entries( {
+							'': [ 'block1' ],
+						} )
+					),
+					tree: new Map(
+						Object.entries( {
+							block1: {
+								clientId: 'block1',
+								name: 'core/with-tranforms-c',
+								attributes: {},
+								innerBlocks: [],
+							},
+						} )
+					),
 					controlledInnerBlocks: {},
-					parents: {},
+					parents: new Map(),
 				},
 				preferences: {
 					insertUsage: {},
@@ -3189,10 +3678,10 @@ describe( 'selectors', () => {
 		it( 'should set frecency', () => {
 			const state = {
 				blocks: {
-					byClientId: {},
-					attributes: {},
-					order: {},
-					parents: {},
+					byClientId: new Map(),
+					attributes: new Map(),
+					order: new Map(),
+					parents: new Map(),
 					cache: {},
 				},
 				preferences: {
@@ -3245,7 +3734,7 @@ describe( 'selectors', () => {
 	} );
 
 	describe( 'getTemplateLock', () => {
-		it( 'should return the general template lock if no clientId was set', () => {
+		it( 'should return the general template lock if no clientId was specified', () => {
 			const state = {
 				settings: { templateLock: 'all' },
 			};
@@ -3253,7 +3742,7 @@ describe( 'selectors', () => {
 			expect( getTemplateLock( state ) ).toBe( 'all' );
 		} );
 
-		it( 'should return undefined if the specified clientId was not found', () => {
+		it( 'should return false if the specified clientId was not found', () => {
 			const state = {
 				settings: { templateLock: 'all' },
 				blockListSettings: {
@@ -3263,10 +3752,10 @@ describe( 'selectors', () => {
 				},
 			};
 
-			expect( getTemplateLock( state, 'ribs' ) ).toBe( undefined );
+			expect( getTemplateLock( state, 'ribs' ) ).toBe( false );
 		} );
 
-		it( 'should return undefined if template lock was not set on the specified block', () => {
+		it( 'should return false if template lock was not set on the specified block', () => {
 			const state = {
 				settings: { templateLock: 'all' },
 				blockListSettings: {
@@ -3276,7 +3765,7 @@ describe( 'selectors', () => {
 				},
 			};
 
-			expect( getTemplateLock( state, 'ribs' ) ).toBe( undefined );
+			expect( getTemplateLock( state, 'chicken' ) ).toBe( false );
 		} );
 
 		it( 'should return the template lock for the specified clientId', () => {
@@ -3410,20 +3899,24 @@ describe( 'selectors', () => {
 
 	describe( 'getLowestCommonAncestorWithSelectedBlock', () => {
 		const blocks = {
-			order: {
-				'': [ 'a', 'b' ],
-				a: [ 'c', 'd' ],
-				d: [ 'e' ],
-				b: [ 'f' ],
-			},
-			parents: {
-				a: '',
-				b: '',
-				c: 'a',
-				d: 'a',
-				e: 'd',
-				f: 'b',
-			},
+			order: new Map(
+				Object.entries( {
+					'': [ 'a', 'b' ],
+					a: [ 'c', 'd' ],
+					d: [ 'e' ],
+					b: [ 'f' ],
+				} )
+			),
+			parents: new Map(
+				Object.entries( {
+					a: '',
+					b: '',
+					c: 'a',
+					d: 'a',
+					e: 'd',
+					f: 'b',
+				} )
+			),
 		};
 
 		it( 'should not be defined if there is no block selected', () => {
@@ -3522,35 +4015,39 @@ describe( 'selectors', () => {
 				},
 			},
 			blocks: {
-				parents: {
-					'client-id-01': '',
-					'client-id-02': 'client-id-01',
-					'client-id-03': 'client-id-02',
-					'client-id-04': 'client-id-03',
-					'client-id-05': 'client-id-03',
-				},
-				byClientId: {
-					'client-id-01': {
-						clientId: 'client-id-01',
-						name: 'core/columns',
-					},
-					'client-id-02': {
-						clientId: 'client-id-02',
-						name: 'core/navigation',
-					},
-					'client-id-03': {
-						clientId: 'client-id-03',
-						name: 'core/navigation-link',
-					},
-					'client-id-04': {
-						clientId: 'client-id-04',
-						name: 'core/navigation-link',
-					},
-					'client-id-05': {
-						clientId: 'client-id-05',
-						name: 'core/navigation-link',
-					},
-				},
+				parents: new Map(
+					Object.entries( {
+						'client-id-01': '',
+						'client-id-02': 'client-id-01',
+						'client-id-03': 'client-id-02',
+						'client-id-04': 'client-id-03',
+						'client-id-05': 'client-id-03',
+					} )
+				),
+				byClientId: new Map(
+					Object.entries( {
+						'client-id-01': {
+							clientId: 'client-id-01',
+							name: 'core/columns',
+						},
+						'client-id-02': {
+							clientId: 'client-id-02',
+							name: 'core/navigation',
+						},
+						'client-id-03': {
+							clientId: 'client-id-03',
+							name: 'core/navigation-link',
+						},
+						'client-id-04': {
+							clientId: 'client-id-04',
+							name: 'core/navigation-link',
+						},
+						'client-id-05': {
+							clientId: 'client-id-05',
+							name: 'core/navigation-link',
+						},
+					} )
+				),
 				cache: {
 					'client-id-01': {},
 					'client-id-02': {},
@@ -3558,9 +4055,11 @@ describe( 'selectors', () => {
 					'client-id-04': {},
 					'client-id-05': {},
 				},
-				order: {
-					'client-id-03': [ 'client-id-04', 'client-id-05' ],
-				},
+				order: new Map(
+					Object.entries( {
+						'client-id-03': [ 'client-id-04', 'client-id-05' ],
+					} )
+				),
 				controlledInnerBlocks: {},
 			},
 		};
@@ -3592,14 +4091,18 @@ describe( 'selectors', () => {
 	describe( '__experimentalGetAllowedPatterns', () => {
 		const state = {
 			blocks: {
-				byClientId: {
-					block1: { name: 'core/test-block-a' },
-					block2: { name: 'core/test-block-b' },
-				},
-				attributes: {
-					block1: {},
-					block2: {},
-				},
+				byClientId: new Map(
+					Object.entries( {
+						block1: { name: 'core/test-block-a' },
+						block2: { name: 'core/test-block-b' },
+					} )
+				),
+				attributes: new Map(
+					Object.entries( {
+						block1: {},
+						block2: {},
+					} )
+				),
 			},
 			blockListSettings: {
 				block1: {
@@ -3651,7 +4154,7 @@ describe( 'selectors', () => {
 		it( 'should return empty array if only patterns hidden from UI exist', () => {
 			expect(
 				__experimentalGetAllowedPatterns( {
-					blocks: { byClientId: {} },
+					blocks: { byClientId: new Map() },
 					blockListSettings: {},
 					settings: {
 						__experimentalBlockPatterns: [
@@ -3723,9 +4226,11 @@ describe( 'selectors', () => {
 	describe( '__experimentalGetPatternsByBlockTypes', () => {
 		const state = {
 			blocks: {
-				byClientId: {
-					block1: { name: 'core/test-block-a' },
-				},
+				byClientId: new Map(
+					Object.entries( {
+						block1: { name: 'core/test-block-a' },
+					} )
+				),
 			},
 			blockListSettings: {
 				block1: {
@@ -3797,10 +4302,12 @@ describe( 'selectors', () => {
 	describe( '__experimentalGetPatternTransformItems', () => {
 		const state = {
 			blocks: {
-				byClientId: {
-					block1: { name: 'core/test-block-a' },
-					block2: { name: 'core/test-block-b' },
-				},
+				byClientId: new Map(
+					Object.entries( {
+						block1: { name: 'core/test-block-a' },
+						block2: { name: 'core/test-block-b' },
+					} )
+				),
 				controlledInnerBlocks: { 'block2-clientId': true },
 			},
 			blockListSettings: {
@@ -4054,10 +4561,10 @@ describe( 'getInserterItems with core blocks prioritization', () => {
 	it( 'should prioritize core blocks by sorting them at the top of the returned list', () => {
 		const state = {
 			blocks: {
-				byClientId: {},
-				attributes: {},
-				order: {},
-				parents: {},
+				byClientId: new Map(),
+				attributes: new Map(),
+				order: new Map(),
+				parents: new Map(),
 				cache: {},
 			},
 			settings: {},
@@ -4085,11 +4592,13 @@ describe( '__unstableGetClientIdWithClientIdsTree', () => {
 	it( "should return a stripped down block object containing only its client ID and its inner blocks' client IDs", () => {
 		const state = {
 			blocks: {
-				order: {
-					'': [ 'foo' ],
-					foo: [ 'bar', 'baz' ],
-					bar: [ 'qux' ],
-				},
+				order: new Map(
+					Object.entries( {
+						'': [ 'foo' ],
+						foo: [ 'bar', 'baz' ],
+						bar: [ 'qux' ],
+					} )
+				),
 			},
 		};
 
@@ -4111,11 +4620,13 @@ describe( '__unstableGetClientIdsTree', () => {
 	it( "should return the full content tree starting from the given root, consisting of stripped down block object containing only its client ID and its inner blocks' client IDs", () => {
 		const state = {
 			blocks: {
-				order: {
-					'': [ 'foo' ],
-					foo: [ 'bar', 'baz' ],
-					bar: [ 'qux' ],
-				},
+				order: new Map(
+					Object.entries( {
+						'': [ 'foo' ],
+						foo: [ 'bar', 'baz' ],
+						bar: [ 'qux' ],
+					} )
+				),
 			},
 		};
 
@@ -4131,11 +4642,13 @@ describe( '__unstableGetClientIdsTree', () => {
 	it( "should return the full content tree starting from the root, consisting of stripped down block object containing only its client ID and its inner blocks' client IDs", () => {
 		const state = {
 			blocks: {
-				order: {
-					'': [ 'foo' ],
-					foo: [ 'bar', 'baz' ],
-					bar: [ 'qux' ],
-				},
+				order: new Map(
+					Object.entries( {
+						'': [ 'foo' ],
+						foo: [ 'bar', 'baz' ],
+						bar: [ 'qux' ],
+					} )
+				),
 			},
 		};
 
@@ -4153,3 +4666,23 @@ describe( '__unstableGetClientIdsTree', () => {
 		] );
 	} );
 } );
+
+describe( 'getLastInsertedBlockClientId', () => {
+	it( 'should return undefined if no blocks have been inserted', () => {
+		const state = {
+			lastBlockInserted: {},
+		};
+
+		expect( getLastInsertedBlockClientId( state ) ).toEqual( undefined );
+	} );
+
+	it( 'should return clientId if blocks have been inserted', () => {
+		const state = {
+			lastBlockInserted: {
+				clientId: '123456',
+			},
+		};
+
+		expect( getLastInsertedBlockClientId( state ) ).toEqual( '123456' );
+	} );
+} );