@wordpress/edit-site 4.0.0 → 4.0.2

package/src/store/index.js

@@ -2,7 +2,6 @@
  * WordPress dependencies
  */
 import { createReduxStore, registerStore } from '@wordpress/data';
-import { controls } from '@wordpress/data-controls';
 
 /**
  * Internal dependencies
@@ -16,7 +15,6 @@ export const storeConfig = {
 	reducer,
 	actions,
 	selectors,
-	controls,
 	persist: [ 'preferences' ],
 };
 

package/src/store/selectors.js

@@ -98,6 +98,8 @@ export const getSettings = createSelector(
 			hasFixedToolbar: isFeatureActive( state, 'fixedToolbar' ),
 			__experimentalSetIsInserterOpened: setIsInserterOpen,
 			__experimentalReusableBlocks: getReusableBlocks( state ),
+			__experimentalPreferPatternsOnRoot:
+				'wp_template' === getEditedPostType( state ),
 		};
 
 		const canUserCreateMedia = getCanUserCreateMedia( state );
@@ -120,6 +122,7 @@ export const getSettings = createSelector(
 		isFeatureActive( state, 'focusMode' ),
 		isFeatureActive( state, 'fixedToolbar' ),
 		getReusableBlocks( state ),
+		getEditedPostType( state ),
 	]
 );
 

package/src/store/test/actions.js

@@ -1,129 +1,223 @@
+/**
+ * WordPress dependencies
+ */
+import apiFetch from '@wordpress/api-fetch';
+import { store as blockEditorStore } from '@wordpress/block-editor';
+import { store as coreStore } from '@wordpress/core-data';
+import { createRegistry } from '@wordpress/data';
+import { store as interfaceStore } from '@wordpress/interface';
+import { store as noticesStore } from '@wordpress/notices';
+
 /**
  * Internal dependencies
  */
-import {
-	toggleFeature,
-	setTemplate,
-	addTemplate,
-	setTemplatePart,
-	setPage,
-	setHomeTemplateId,
-	setIsListViewOpened,
-} from '../actions';
+import { store as editSiteStore } from '..';
+
+jest.useRealTimers();
+
+const ENTITY_TYPES = {
+	wp_template: {
+		description: 'Templates to include in your theme.',
+		hierarchical: false,
+		name: 'Templates',
+		rest_base: 'templates',
+		rest_namespace: 'wp/v2',
+		slug: 'wp_template',
+		taxonomies: [],
+	},
+};
+
+function createRegistryWithStores() {
+	// create a registry
+	const registry = createRegistry();
+
+	// register stores
+	registry.register( blockEditorStore );
+	registry.register( coreStore );
+	registry.register( editSiteStore );
+	registry.register( interfaceStore );
+	registry.register( noticesStore );
+
+	return registry;
+}
 
 describe( 'actions', () => {
 	describe( 'toggleFeature', () => {
-		it( 'should return TOGGLE_FEATURE action', () => {
-			const feature = 'name';
-			expect( toggleFeature( feature ) ).toEqual( {
-				type: 'TOGGLE_FEATURE',
-				feature,
-			} );
+		it( 'should toggle a feature flag', () => {
+			const registry = createRegistryWithStores();
+
+			registry.dispatch( editSiteStore ).toggleFeature( 'name' );
+			expect(
+				registry.select( editSiteStore ).isFeatureActive( 'name' )
+			).toBe( true );
 		} );
 	} );
 
 	describe( 'setTemplate', () => {
-		it( 'should return the SET_TEMPLATE action when slug is provided', () => {
-			const templateId = 1;
-			const templateSlug = 'archive';
-			const it = setTemplate( templateId, templateSlug );
-			expect( it.next().value ).toEqual( {
-				type: 'SET_TEMPLATE',
-				templateId,
-				page: { context: { templateSlug } },
-			} );
+		const ID = 1;
+		const SLUG = 'archive';
+
+		it( 'should set the template when slug is provided', async () => {
+			const registry = createRegistryWithStores();
+
+			await registry.dispatch( editSiteStore ).setTemplate( ID, SLUG );
+
+			const select = registry.select( editSiteStore );
+			expect( select.getEditedPostId() ).toBe( ID );
+			expect( select.getPage().context.templateSlug ).toBe( SLUG );
 		} );
-		it( 'should return the SET_TEMPLATE by getting the template slug', () => {
-			const templateId = 1;
-			const template = { slug: 'index' };
-			const it = setTemplate( templateId );
-			expect( it.next().value ).toEqual( {
-				type: '@@data/RESOLVE_SELECT',
-				storeKey: 'core',
-				selectorName: 'getEntityRecord',
-				args: [ 'postType', 'wp_template', templateId ],
-			} );
-			expect( it.next( template ).value ).toEqual( {
-				type: 'SET_TEMPLATE',
-				templateId,
-				page: { context: { templateSlug: template.slug } },
+
+		it( 'should set the template by fetching the template slug', async () => {
+			const registry = createRegistryWithStores();
+
+			apiFetch.setFetchHandler( async ( options ) => {
+				const { method = 'GET', path } = options;
+				if ( method === 'GET' ) {
+					if ( path.startsWith( '/wp/v2/types' ) ) {
+						return ENTITY_TYPES;
+					}
+
+					if ( path.startsWith( `/wp/v2/templates/${ ID }` ) ) {
+						return { id: ID, slug: SLUG };
+					}
+				}
+
+				throw {
+					code: 'unknown_path',
+					message: `Unknown path: ${ method } ${ path }`,
+				};
 			} );
+
+			await registry.dispatch( editSiteStore ).setTemplate( ID );
+
+			const select = registry.select( editSiteStore );
+			expect( select.getEditedPostId() ).toBe( ID );
+			expect( select.getPage().context.templateSlug ).toBe( SLUG );
 		} );
 	} );
 
 	describe( 'addTemplate', () => {
-		it( 'should yield the DISPATCH control to create the template and return the SET_TEMPLATE action', () => {
-			const template = { slug: 'index' };
-			const newTemplate = { id: 1, slug: 'index' };
-
-			const it = addTemplate( template );
-			expect( it.next().value ).toEqual( {
-				type: '@@data/DISPATCH',
-				storeKey: 'core',
-				actionName: 'saveEntityRecord',
-				args: [ 'postType', 'wp_template', template ],
-			} );
-			expect( it.next( newTemplate ) ).toEqual( {
-				value: {
-					type: 'SET_TEMPLATE',
-					templateId: newTemplate.id,
-					page: { context: { templateSlug: newTemplate.slug } },
-				},
-				done: true,
+		it( 'should issue a REST request to create the template and then set it', async () => {
+			const registry = createRegistryWithStores();
+
+			const ID = 1;
+			const SLUG = 'index';
+
+			apiFetch.setFetchHandler( async ( options ) => {
+				const { method = 'GET', path, data } = options;
+
+				if ( method === 'GET' && path.startsWith( '/wp/v2/types' ) ) {
+					return ENTITY_TYPES;
+				}
+
+				if (
+					method === 'POST' &&
+					path.startsWith( '/wp/v2/templates' )
+				) {
+					return { id: ID, slug: data.slug };
+				}
+
+				throw {
+					code: 'unknown_path',
+					message: `Unknown path: ${ method } ${ path }`,
+				};
 			} );
+
+			await registry
+				.dispatch( editSiteStore )
+				.addTemplate( { slug: SLUG } );
+
+			const select = registry.select( editSiteStore );
+			expect( select.getEditedPostId() ).toBe( ID );
+			expect( select.getPage().context.templateSlug ).toBe( SLUG );
 		} );
 	} );
 
 	describe( 'setTemplatePart', () => {
-		it( 'should return the SET_TEMPLATE_PART action', () => {
-			const templatePartId = 1;
-			expect( setTemplatePart( templatePartId ) ).toEqual( {
-				type: 'SET_TEMPLATE_PART',
-				templatePartId,
-			} );
+		it( 'should set template part', () => {
+			const registry = createRegistryWithStores();
+
+			const ID = 1;
+			registry.dispatch( editSiteStore ).setTemplatePart( ID );
+
+			const select = registry.select( editSiteStore );
+			expect( select.getEditedPostId() ).toBe( ID );
+			expect( select.getEditedPostType() ).toBe( 'wp_template_part' );
 		} );
 	} );
 
 	describe( 'setPage', () => {
-		it( 'should yield the FIND_TEMPLATE control and return the SET_PAGE action', () => {
-			const page = { path: '/' };
-
-			const it = setPage( page );
-			expect( it.next().value ).toEqual( {
-				type: '@@data/RESOLVE_SELECT',
-				storeKey: 'core',
-				selectorName: '__experimentalGetTemplateForLink',
-				args: [ page.path ],
-			} );
-			expect( it.next( { id: 'emptytheme//single' } ).value ).toEqual( {
-				type: 'SET_PAGE',
-				page,
-				templateId: 'emptytheme//single',
+		it( 'should find the template and then set the page', async () => {
+			const registry = createRegistryWithStores();
+
+			const ID = 'emptytheme//single';
+			const SLUG = 'single';
+
+			window.fetch = async ( path ) => {
+				if ( path === '/?_wp-find-template=true' ) {
+					return {
+						json: async () => ( { data: { id: ID, slug: SLUG } } ),
+					};
+				}
+
+				throw {
+					code: 'unknown_path',
+					message: `Unknown path: ${ path }`,
+				};
+			};
+
+			apiFetch.setFetchHandler( async ( options ) => {
+				const { method = 'GET', path } = options;
+
+				if ( method === 'GET' ) {
+					if ( path.startsWith( '/wp/v2/types' ) ) {
+						return ENTITY_TYPES;
+					}
+
+					if ( path.startsWith( `/wp/v2/templates/${ ID }` ) ) {
+						return { id: ID, slug: SLUG };
+					}
+				}
+
+				throw {
+					code: 'unknown_path',
+					message: `Unknown path: ${ method } ${ path }`,
+				};
 			} );
-			expect( it.next().done ).toBe( true );
+
+			await registry.dispatch( editSiteStore ).setPage( { path: '/' } );
+
+			const select = registry.select( editSiteStore );
+			expect( select.getEditedPostId() ).toBe( 'emptytheme//single' );
+			expect( select.getEditedPostType() ).toBe( 'wp_template' );
+			expect( select.getPage().path ).toBe( '/' );
 		} );
 	} );
 
 	describe( 'setHomeTemplateId', () => {
-		it( 'should return the SET_HOME_TEMPLATE action', () => {
-			const homeTemplateId = 90;
-			expect( setHomeTemplateId( homeTemplateId ) ).toEqual( {
-				type: 'SET_HOME_TEMPLATE',
-				homeTemplateId,
-			} );
+		it( 'should set the home template ID', () => {
+			const registry = createRegistryWithStores();
+
+			registry.dispatch( editSiteStore ).setHomeTemplateId( 90 );
+			expect( registry.select( editSiteStore ).getHomeTemplateId() ).toBe(
+				90
+			);
 		} );
 	} );
 
 	describe( 'setIsListViewOpened', () => {
-		it( 'should return the SET_IS_LIST_VIEW_OPENED action', () => {
-			expect( setIsListViewOpened( true ) ).toEqual( {
-				type: 'SET_IS_LIST_VIEW_OPENED',
-				isOpen: true,
-			} );
-			expect( setIsListViewOpened( false ) ).toEqual( {
-				type: 'SET_IS_LIST_VIEW_OPENED',
-				isOpen: false,
-			} );
+		it( 'should set the list view opened state', () => {
+			const registry = createRegistryWithStores();
+
+			registry.dispatch( editSiteStore ).setIsListViewOpened( true );
+			expect( registry.select( editSiteStore ).isListViewOpened() ).toBe(
+				true
+			);
+
+			registry.dispatch( editSiteStore ).setIsListViewOpened( false );
+			expect( registry.select( editSiteStore ).isListViewOpened() ).toBe(
+				false
+			);
 		} );
 	} );
 } );

package/src/store/test/selectors.js

@@ -106,7 +106,11 @@ describe( 'selectors', () => {
 		it( "returns the settings when the user can't create media", () => {
 			canUser.mockReturnValueOnce( false );
 			canUser.mockReturnValueOnce( false );
-			const state = { settings: {}, preferences: {} };
+			const state = {
+				settings: {},
+				preferences: {},
+				editedPost: { type: 'wp_template' },
+			};
 			const setInserterOpened = () => {};
 			expect( getSettings( state, setInserterOpened ) ).toEqual( {
 				outlineMode: true,
@@ -114,6 +118,7 @@ describe( 'selectors', () => {
 				hasFixedToolbar: false,
 				__experimentalSetIsInserterOpened: setInserterOpened,
 				__experimentalReusableBlocks: [],
+				__experimentalPreferPatternsOnRoot: true,
 			} );
 		} );
 
@@ -126,6 +131,7 @@ describe( 'selectors', () => {
 						fixedToolbar: true,
 					},
 				},
+				editedPost: { type: 'wp_template_part' },
 			};
 			const setInserterOpened = () => {};
 
@@ -137,6 +143,7 @@ describe( 'selectors', () => {
 				__experimentalSetIsInserterOpened: setInserterOpened,
 				__experimentalReusableBlocks: [],
 				mediaUpload: expect.any( Function ),
+				__experimentalPreferPatternsOnRoot: false,
 			} );
 		} );
 	} );