@wordpress/block-editor 15.11.1-next.v.0 → 15.12.0

package/src/store/test/reducer.js

@@ -3977,6 +3977,9 @@ describe( 'state', () => {
 				expect( editingState.derivedBlockEditingModes ).toEqual(
 					new Map(
 						Object.entries( {
+							// blocks outside the section are disabled.
+							'': 'disabled',
+							// blocks inside the section are fully editable.
 							'group-1': 'default',
 							'paragraph-1': 'default',
 							'group-2': 'default',
@@ -4086,9 +4089,13 @@ describe( 'state', () => {
 				expect( editingSection1.derivedBlockEditingModes ).toEqual(
 					new Map(
 						Object.entries( {
+							// Blocks outside the section are disabled.
+							'': 'disabled',
+							'section-2': 'disabled',
+							'section-2-paragraph': 'disabled',
+							// Block inside the section are fully editable.
 							'section-1': 'default',
 							'section-1-paragraph': 'default',
-							'section-2-paragraph': 'contentOnly',
 						} )
 					)
 				);
@@ -4287,294 +4294,279 @@ describe( 'state', () => {
 			} );
 		} );
 
-		// Tests for the contentOnly experiments pattern.
-		// If/when the experiment is stabilized, this wrapping `describe` and
-		// `beforeAll`/`afterAll` can be removed, un-nesting the tests within.
-		describe( 'contentOnly patterns experiment', () => {
+		describe( 'unsynced patterns', () => {
+			let initialState;
 			beforeAll( () => {
-				globalThis.window.__experimentalContentOnlyPatternInsertion = true;
-			} );
-
-			afterAll( () => {
-				delete globalThis.window
-					.__experimentalContentOnlyPatternInsertion;
-			} );
-
-			describe( 'unsynced patterns', () => {
-				let initialState;
-				beforeAll( () => {
-					initialState = dispatchActions(
-						[
-							{
-								type: 'RESET_BLOCKS',
-								blocks: [
-									{
-										name: 'core/group',
-										clientId: 'group-1',
-										attributes: {
-											metadata: {
-												patternName: 'test-pattern',
-											},
+				initialState = dispatchActions(
+					[
+						{
+							type: 'RESET_BLOCKS',
+							blocks: [
+								{
+									name: 'core/group',
+									clientId: 'group-1',
+									attributes: {
+										metadata: {
+											patternName: 'test-pattern',
 										},
-										innerBlocks: [
-											{
-												name: 'core/paragraph',
-												clientId: 'paragraph-1',
-												attributes: {},
-												innerBlocks: [],
-											},
-											{
-												name: 'core/group',
-												clientId: 'group-2',
-												attributes: {},
-												innerBlocks: [
-													{
-														name: 'core/paragraph',
-														clientId: 'paragraph-2',
-														attributes: {},
-														innerBlocks: [],
-													},
-												],
-											},
-										],
 									},
-								],
-							},
-						],
-						testReducer,
-						initialState
-					);
-				} );
+									innerBlocks: [
+										{
+											name: 'core/paragraph',
+											clientId: 'paragraph-1',
+											attributes: {},
+											innerBlocks: [],
+										},
+										{
+											name: 'core/group',
+											clientId: 'group-2',
+											attributes: {},
+											innerBlocks: [
+												{
+													name: 'core/paragraph',
+													clientId: 'paragraph-2',
+													attributes: {},
+													innerBlocks: [],
+												},
+											],
+										},
+									],
+								},
+							],
+						},
+					],
+					testReducer,
+					initialState
+				);
+			} );
 
-				it( 'returns the expected block editing modes for an unsynced pattern', () => {
-					expect( initialState.derivedBlockEditingModes ).toEqual(
-						new Map(
-							Object.entries( {
-								'paragraph-1': 'contentOnly',
-								'group-2': 'disabled',
-								'paragraph-2': 'contentOnly',
-							} )
-						)
-					);
-				} );
+			it( 'returns the expected block editing modes for an unsynced pattern', () => {
+				expect( initialState.derivedBlockEditingModes ).toEqual(
+					new Map(
+						Object.entries( {
+							'paragraph-1': 'contentOnly',
+							'group-2': 'disabled',
+							'paragraph-2': 'contentOnly',
+						} )
+					)
+				);
+			} );
 
-				it( 'removes block editing modes when an unsynced pattern is removed', () => {
-					const { derivedBlockEditingModes } = dispatchActions(
-						[
-							{
-								type: 'REMOVE_BLOCKS',
-								clientIds: [ 'group-1' ],
-							},
-						],
-						testReducer,
-						initialState
-					);
+			it( 'removes block editing modes when an unsynced pattern is removed', () => {
+				const { derivedBlockEditingModes } = dispatchActions(
+					[
+						{
+							type: 'REMOVE_BLOCKS',
+							clientIds: [ 'group-1' ],
+						},
+					],
+					testReducer,
+					initialState
+				);
 
-					expect( derivedBlockEditingModes ).toEqual( new Map() );
-				} );
+				expect( derivedBlockEditingModes ).toEqual( new Map() );
+			} );
 
-				it( 'removes block editing modes when the `patternName` attribute is removed from the unsynced pattern', () => {
-					const { derivedBlockEditingModes } = dispatchActions(
-						[
-							{
-								type: 'UPDATE_BLOCK_ATTRIBUTES',
-								clientIds: [ 'group-1' ],
-								attributes: {
-									metadata: {
-										patternName: undefined,
-									},
+			it( 'removes block editing modes when the `patternName` attribute is removed from the unsynced pattern', () => {
+				const { derivedBlockEditingModes } = dispatchActions(
+					[
+						{
+							type: 'UPDATE_BLOCK_ATTRIBUTES',
+							clientIds: [ 'group-1' ],
+							attributes: {
+								metadata: {
+									patternName: undefined,
 								},
 							},
-						],
-						testReducer,
-						initialState
-					);
+						},
+					],
+					testReducer,
+					initialState
+				);
 
-					expect( derivedBlockEditingModes ).toEqual( new Map() );
-				} );
+				expect( derivedBlockEditingModes ).toEqual( new Map() );
+			} );
 
-				it( 'allows explicitly set blockEditingModes to override the unsynced pattern editing modes', () => {
-					const { derivedBlockEditingModes } = dispatchActions(
-						[
-							{
-								type: 'SET_BLOCK_EDITING_MODE',
-								clientId: 'paragraph-2',
-								mode: 'disabled',
-							},
-						],
-						testReducer,
-						initialState
-					);
+			it( 'allows explicitly set blockEditingModes to override the unsynced pattern editing modes', () => {
+				const { derivedBlockEditingModes } = dispatchActions(
+					[
+						{
+							type: 'SET_BLOCK_EDITING_MODE',
+							clientId: 'paragraph-2',
+							mode: 'disabled',
+						},
+					],
+					testReducer,
+					initialState
+				);
 
-					expect( derivedBlockEditingModes ).toEqual(
-						new Map(
-							Object.entries( {
-								'paragraph-1': 'contentOnly',
-								'group-2': 'disabled',
-								// Paragraph 2 already has an explicit mode, so isn't set as a derived mode.
-							} )
-						)
-					);
-				} );
+				expect( derivedBlockEditingModes ).toEqual(
+					new Map(
+						Object.entries( {
+							'paragraph-1': 'contentOnly',
+							'group-2': 'disabled',
+							// Paragraph 2 already has an explicit mode, so isn't set as a derived mode.
+						} )
+					)
+				);
+			} );
 
-				it( 'sets the correct block editing modes when a new unsynced pattern is inserted', () => {
-					const { derivedBlockEditingModes } = dispatchActions(
-						[
-							{
-								type: 'INSERT_BLOCKS',
-								rootClientId: '',
-								index: 1,
-								blocks: [
-									{
-										name: 'core/group',
-										clientId: 'group-3',
-										attributes: {
-											metadata: {
-												patternName: 'test-pattern-2',
-											},
+			it( 'sets the correct block editing modes when a new unsynced pattern is inserted', () => {
+				const { derivedBlockEditingModes } = dispatchActions(
+					[
+						{
+							type: 'INSERT_BLOCKS',
+							rootClientId: '',
+							index: 1,
+							blocks: [
+								{
+									name: 'core/group',
+									clientId: 'group-3',
+									attributes: {
+										metadata: {
+											patternName: 'test-pattern-2',
 										},
-										innerBlocks: [
-											{
-												name: 'core/paragraph',
-												clientId: 'paragraph-3',
-												attributes: {},
-												innerBlocks: [],
-											},
-										],
 									},
-								],
-							},
-						],
-						testReducer,
-						initialState
-					);
+									innerBlocks: [
+										{
+											name: 'core/paragraph',
+											clientId: 'paragraph-3',
+											attributes: {},
+											innerBlocks: [],
+										},
+									],
+								},
+							],
+						},
+					],
+					testReducer,
+					initialState
+				);
 
-					expect( derivedBlockEditingModes ).toEqual(
-						new Map(
-							Object.entries( {
-								'paragraph-1': 'contentOnly',
-								'group-2': 'disabled',
-								'paragraph-2': 'contentOnly',
-								'paragraph-3': 'contentOnly',
-							} )
-						)
-					);
-				} );
+				expect( derivedBlockEditingModes ).toEqual(
+					new Map(
+						Object.entries( {
+							'paragraph-1': 'contentOnly',
+							'group-2': 'disabled',
+							'paragraph-2': 'contentOnly',
+							'paragraph-3': 'contentOnly',
+						} )
+					)
+				);
 			} );
+		} );
 
-			describe( 'template parts', () => {
-				let initialState;
-				beforeAll( () => {
-					// Simulates how the editor typically inserts controlled blocks,
-					// - first the template part is inserted with no inner blocks.
-					// - next the template part is marked as a controlled block.
-					// - finally, once the inner blocks of the template part are received, they're inserted.
-					initialState = dispatchActions(
-						[
-							{
-								type: 'RESET_BLOCKS',
-								blocks: [
-									{
-										name: 'core/template-part',
-										clientId: 'template-part',
-										attributes: {},
-										innerBlocks: [],
-									},
-								],
-							},
-							{
-								type: 'SET_HAS_CONTROLLED_INNER_BLOCKS',
-								clientId: 'template-part',
-								hasControlledInnerBlocks: true,
-							},
-							{
-								type: 'REPLACE_INNER_BLOCKS',
-								rootClientId: 'template-part',
-								blocks: [
-									{
-										name: 'core/paragraph',
-										clientId: 'template-part-paragraph',
-										attributes: {},
-										innerBlocks: [],
-									},
-									{
-										name: 'core/group',
-										clientId: 'template-part-group',
-										attributes: {},
-										innerBlocks: [
-											{
-												name: 'core/paragraph',
-												clientId:
-													'template-part-grouped-paragraph',
-												attributes: {},
-												innerBlocks: [],
-											},
-										],
-									},
-								],
-							},
-						],
-						testReducer,
-						initialState
-					);
-				} );
+		describe( 'template parts', () => {
+			let initialState;
+			beforeAll( () => {
+				// Simulates how the editor typically inserts controlled blocks,
+				// - first the template part is inserted with no inner blocks.
+				// - next the template part is marked as a controlled block.
+				// - finally, once the inner blocks of the template part are received, they're inserted.
+				initialState = dispatchActions(
+					[
+						{
+							type: 'RESET_BLOCKS',
+							blocks: [
+								{
+									name: 'core/template-part',
+									clientId: 'template-part',
+									attributes: {},
+									innerBlocks: [],
+								},
+							],
+						},
+						{
+							type: 'SET_HAS_CONTROLLED_INNER_BLOCKS',
+							clientId: 'template-part',
+							hasControlledInnerBlocks: true,
+						},
+						{
+							type: 'REPLACE_INNER_BLOCKS',
+							rootClientId: 'template-part',
+							blocks: [
+								{
+									name: 'core/paragraph',
+									clientId: 'template-part-paragraph',
+									attributes: {},
+									innerBlocks: [],
+								},
+								{
+									name: 'core/group',
+									clientId: 'template-part-group',
+									attributes: {},
+									innerBlocks: [
+										{
+											name: 'core/paragraph',
+											clientId:
+												'template-part-grouped-paragraph',
+											attributes: {},
+											innerBlocks: [],
+										},
+									],
+								},
+							],
+						},
+					],
+					testReducer,
+					initialState
+				);
+			} );
 
-				it( 'returns the expected block editing modes for synced patterns', () => {
-					expect( initialState.derivedBlockEditingModes ).toEqual(
-						new Map(
-							Object.entries( {
-								'template-part-paragraph': 'contentOnly',
-								'template-part-group': 'disabled',
-								'template-part-grouped-paragraph':
-									'contentOnly',
-							} )
-						)
-					);
-				} );
+			it( 'returns the expected block editing modes for synced patterns', () => {
+				expect( initialState.derivedBlockEditingModes ).toEqual(
+					new Map(
+						Object.entries( {
+							'template-part-paragraph': 'contentOnly',
+							'template-part-group': 'disabled',
+							'template-part-grouped-paragraph': 'contentOnly',
+						} )
+					)
+				);
+			} );
 
-				it( 'removes the block editing modes when the template part is removed', () => {
-					const { derivedBlockEditingModes } = dispatchActions(
-						[
-							{
-								type: 'REMOVE_BLOCKS',
-								clientIds: [ 'template-part' ],
-							},
-							{
-								type: 'SET_HAS_CONTROLLED_INNER_BLOCKS',
-								clientId: 'template-part',
-								hasControlledInnerBlocks: false,
-							},
-						],
-						testReducer,
-						initialState
-					);
+			it( 'removes the block editing modes when the template part is removed', () => {
+				const { derivedBlockEditingModes } = dispatchActions(
+					[
+						{
+							type: 'REMOVE_BLOCKS',
+							clientIds: [ 'template-part' ],
+						},
+						{
+							type: 'SET_HAS_CONTROLLED_INNER_BLOCKS',
+							clientId: 'template-part',
+							hasControlledInnerBlocks: false,
+						},
+					],
+					testReducer,
+					initialState
+				);
 
-					expect( derivedBlockEditingModes ).toEqual( new Map() );
-				} );
+				expect( derivedBlockEditingModes ).toEqual( new Map() );
+			} );
 
-				it( 'allows explicitly set blockEditingModes to override the template part editing modes', () => {
-					const { derivedBlockEditingModes } = dispatchActions(
-						[
-							{
-								type: 'SET_BLOCK_EDITING_MODE',
-								clientId: 'template-part-grouped-paragraph',
-								mode: 'disabled',
-							},
-						],
-						testReducer,
-						initialState
-					);
+			it( 'allows explicitly set blockEditingModes to override the template part editing modes', () => {
+				const { derivedBlockEditingModes } = dispatchActions(
+					[
+						{
+							type: 'SET_BLOCK_EDITING_MODE',
+							clientId: 'template-part-grouped-paragraph',
+							mode: 'disabled',
+						},
+					],
+					testReducer,
+					initialState
+				);
 
-					expect( derivedBlockEditingModes ).toEqual(
-						new Map(
-							Object.entries( {
-								'template-part-paragraph': 'contentOnly',
-								'template-part-group': 'disabled',
-								// template-part-grouped-paragraph already has an explicit mode, so isn't set as a derived mode.
-							} )
-						)
-					);
-				} );
+				expect( derivedBlockEditingModes ).toEqual(
+					new Map(
+						Object.entries( {
+							'template-part-paragraph': 'contentOnly',
+							'template-part-group': 'disabled',
+							// template-part-grouped-paragraph already has an explicit mode, so isn't set as a derived mode.
+						} )
+					)
+				);
 			} );
 		} );
 	} );

package/src/utils/fit-text-utils.js

@@ -18,11 +18,26 @@ function findOptimalFontSize( textElement, applyFontSize ) {
 	let bestSize = minSize;
 
 	const computedStyle = window.getComputedStyle( textElement );
-	const paddingLeft = parseFloat( computedStyle.paddingLeft ) || 0;
-	const paddingRight = parseFloat( computedStyle.paddingRight ) || 0;
+	let paddingLeft = parseFloat( computedStyle.paddingLeft ) || 0;
+	let paddingRight = parseFloat( computedStyle.paddingRight ) || 0;
 	const range = document.createRange();
 	range.selectNodeContents( textElement );
-	let maxclientHeight = textElement.clientHeight;
+
+	let referenceElement = textElement;
+	const parentElement = textElement.parentElement;
+	if ( parentElement ) {
+		const parentElementComputedStyle =
+			window.getComputedStyle( parentElement );
+		if ( parentElementComputedStyle?.display === 'flex' ) {
+			referenceElement = parentElement;
+			paddingLeft +=
+				parseFloat( parentElementComputedStyle.paddingLeft ) || 0;
+			paddingRight +=
+				parseFloat( parentElementComputedStyle.paddingRight ) || 0;
+		}
+	}
+	let maxclientHeight = referenceElement.clientHeight;
+
 	while ( minSize <= maxSize ) {
 		const midSize = Math.floor( ( minSize + maxSize ) / 2 );
 		applyFontSize( midSize );
@@ -36,12 +51,13 @@ function findOptimalFontSize( textElement, applyFontSize ) {
 		// Check if text fits within the element's width and is not
 		// overflowing into the padding area.
 		const fitsWidth =
-			textElement.scrollWidth <= textElement.clientWidth &&
-			textWidth <= textElement.clientWidth - paddingLeft - paddingRight;
+			textElement.scrollWidth <= referenceElement.clientWidth &&
+			textWidth <=
+				referenceElement.clientWidth - paddingLeft - paddingRight;
 		// Check if text fits within the element's height.
 		const fitsHeight =
 			alreadyHasScrollableHeight ||
-			textElement.scrollHeight <= textElement.clientHeight ||
+			textElement.scrollHeight <= referenceElement.clientHeight ||
 			textElement.scrollHeight <= maxclientHeight;
 
 		// When there are calculated line heights, text may jump in height
@@ -49,8 +65,8 @@ function findOptimalFontSize( textElement, applyFontSize ) {
 		// making text not fit.
 		// We store a maximum reference height: the maximum reference element height that was observed
 		// during the loop to avoid issues with such jumps.
-		if ( textElement.clientHeight > maxclientHeight ) {
-			maxclientHeight = textElement.clientHeight;
+		if ( referenceElement.clientHeight > maxclientHeight ) {
+			maxclientHeight = referenceElement.clientHeight;
 		}
 
 		if ( fitsWidth && fitsHeight ) {

package/build/components/content-lock/index.cjs

@@ -1,31 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// packages/block-editor/src/components/content-lock/index.js
-var content_lock_exports = {};
-__export(content_lock_exports, {
-  ModifyContentOnlySectionMenuItem: () => import_modify_content_lock_menu_item.ModifyContentOnlySectionMenuItem
-});
-module.exports = __toCommonJS(content_lock_exports);
-var import_modify_content_lock_menu_item = require("./modify-content-lock-menu-item.cjs");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ModifyContentOnlySectionMenuItem
-});
-//# sourceMappingURL=index.cjs.map

package/build/components/content-lock/index.cjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/components/content-lock/index.js"],
-  "sourcesContent": ["export { ModifyContentOnlySectionMenuItem } from './modify-content-lock-menu-item';\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,2CAAiD;",
-  "names": []
-}