Editor: Cache block meta-sourcing for getBlock selector

packages/editor/src/store/selectors.js

@@ -40,6 +40,7 @@ import { addQueryArgs } from '@wordpress/url';
  */
 import { PREFERENCES_DEFAULTS } from './defaults';
 import { EDIT_MERGE_PROPERTIES } from './constants';
+import createWeakCache from '../utils/create-weak-cache';
 
 /***
  * Module constants
@@ -66,6 +67,21 @@ const ONE_MINUTE_IN_MS = 60 * 1000;
  */
 const EMPTY_ARRAY = [];
 
+/**
+ * Given a block type object, returns true if an attribute value is sourced
+ * from a meta property, or false otherwise.
+ *
+ * The value is cached weakly by strict object reference to the provided block
+ * type argument.
+ *
+ * @param {WPBlockType} blockType Block type against which to test.
+ *
+ * @return {boolean} Whether block type has an meta-sourced attribute.
+ */
+const hasMetaSourcedAttribute = createWeakCache( ( blockType ) => {
+	return some( blockType.attributes, { source: 'meta' } );
+} );
+
 /**
  * Returns true if any past editor history snapshots exist, or false otherwise.
  *
@@ -649,7 +665,7 @@ export const getBlockAttributes = createSelector(
 		// TODO: Create generic external sourcing pattern, not explicitly
 		// targeting meta attributes.
 		const type = getBlockType( block.name );
-		if ( type ) {
+		if ( type && hasMetaSourcedAttribute( type ) ) {
 			attributes = reduce( type.attributes, ( result, value, key ) => {
 				if ( value.source === 'meta' ) {
 					if ( result === attributes ) {

packages/editor/src/utils/create-weak-cache.js

@@ -0,0 +1,25 @@
+/**
+ * Returns a function which caches a computed value on a given object key. Due
+ * to its caching being achieved by WeakCache, the function must only accept a
+ * valid WeakMap key as its argument (objects, arrays). The function is only
+ * passed the key; any other arguments are discarded.
+ *
+ * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap
+ *
+ * @param {Function} getCacheValue Function to compute the cache value.
+ *
+ * @return {Function} Function whose computed value is weakly cached.
+ */
+function createWeakCache( getCacheValue ) {
+	const cache = new WeakMap();
+
+	return ( key ) => {
+		if ( ! cache.has( key ) ) {
+			cache.set( key, getCacheValue( key ) );
+		}
+
+		return cache.get( key );
+	};
+}
+
+export default createWeakCache;

packages/editor/src/utils/test/create-weak-cache.js

@@ -0,0 +1,41 @@
+/**
+ * Internal dependencies
+ */
+import createWeakCache from '../create-weak-cache';
+
+describe( 'createWeakCache', () => {
+	const getNumKeys = jest.fn().mockImplementation( ( object ) => Object.keys( object ).length );
+	const getNumKeysCached = createWeakCache( getNumKeys );
+
+	beforeEach( () => {
+		getNumKeys.mockClear();
+	} );
+
+	it( 'should return the value from the function argument', () => {
+		const object = { a: 1 };
+
+		expect( getNumKeysCached( object ) ).toBe( 1 );
+	} );
+
+	it( 'should return the value from cache', () => {
+		const object = { a: 1 };
+
+		expect( getNumKeysCached( object ) ).toBe( 1 );
+		expect( getNumKeysCached( object ) ).toBe( 1 );
+		expect( getNumKeys ).toHaveBeenCalledTimes( 1 );
+	} );
+
+	it( 'should return the value from the function argument on new reference', () => {
+		expect( getNumKeysCached( { a: 1 } ) ).toBe( 1 );
+		expect( getNumKeysCached( { a: 1 } ) ).toBe( 1 );
+		expect( getNumKeys ).toHaveBeenCalledTimes( 2 );
+	} );
+
+	it( 'should throw on invalid key argument', () => {
+		expect( () => getNumKeysCached( undefined ) ).toThrow();
+	} );
+
+	it( 'should discard additional arguments', () => {
+		expect( createWeakCache( ( a, b ) => b || 'ok' )( {}, 10 ) ).toBe( 'ok' );
+	} );
+} );