@total_onion/onion-library 1.0.0

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,34 @@
+# This workflow will run tests using node and then publish a package to NPM when a release is created
+# For more information see: https://help.github.com/actions/language-and-framework-guides/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 16
+      - run: npm ci
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 16
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/.prettierrc

@@ -0,0 +1,22 @@
+{
+	"useTabs": true,
+	"overrides": [
+		{
+			"files": "*.test.js",
+			"options": {
+				"semi": true
+			}
+		},
+		{
+			"files": ["*.js", "*.css", "*.scss"],
+			"options": {
+				"useTabs": true,
+				"semi": true,
+				"singleQuote": true,
+				"trailingComma": "none",
+				"tabWidth": 4,
+				"bracketSpacing": false
+			}
+		}
+	]
+}

package/README.md

@@ -0,0 +1,33 @@
+# cbl-component-library
+
+Front end components for gcms sites
+
+## Installation
+
+Install with npm or yarn..
+
+`npm install --save-dev @pernod-ricard-global-cms/cbl-component-library`
+
+`yarn add -D @pernod-ricard-global-cms/cbl-component-library`
+
+If you don't have the scripts already in your package.json you can add these and use them to install and update components.
+
+`"install-component": "node ./node_modules/@pernod-ricard-global-cms/cbl-component-library/install-component.js", "upgrade-component": "node ./node_modules/@pernod-ricard-global-cms/cbl-component-library/upgrade-component.js", "list-components": "node ./node_modules/@pernod-ricard-global-cms/cbl-component-library/list-components.js",`
+
+eg you can list the available components with
+
+`yarn list-components`
+
+and then you can install and component with
+
+`yarn install-component <name-of-component>`
+
+## Run unit tests
+
+Go to the folder
+
+`yarn install`
+
+then, to run unit tests, 
+
+`yarn test`

package/__spec__/copyBlockComponent.spec.js

@@ -0,0 +1,94 @@
+const fs = require('fs');
+const path = require('path');
+const { promisify } = require('util');
+
+// Import the function to be tested
+const updateComponent = require('../update-component');
+
+// Promisify the fs functions used in the copyBlockComponent function
+const readdirPromisified = promisify(fs.readdir);
+const accessPromisified = promisify(fs.access);
+
+// Create a utility function to remove the file (used after each test)
+const removeFile = async (filePath) => {
+	try {
+		await fs.promises.unlink(filePath);
+	} catch (err) {
+		// If the file doesn't exist, ignore the error
+		if (err.code !== 'ENOENT') {
+			console.error('Error removing the file:', err);
+		}
+	}
+};
+
+xdescribe('copyBlockComponent function', () => {
+	const libraryPath = 'testFiles/library'; // Assuming the libraryPath is defined for the tests
+	const componentName = 'TestComponent';
+
+	// Before each test, create the source directory with some test files
+	beforeEach(async () => {
+		try {
+			const sourceDir = path.join(libraryPath, 'components', componentName);
+			await fs.promises.mkdir(sourceDir, { recursive: true });
+			await fs.promises.writeFile(path.join(sourceDir, 'TestComponent.php'), 'Test PHP content');
+			await fs.promises.writeFile(path.join(sourceDir, 'TestComponent.js'), 'Test JS content');
+			await fs.promises.writeFile(path.join(sourceDir, 'TestComponent.scss'), 'Test SCSS content');
+			await fs.promises.writeFile(path.join(sourceDir, 'TestComponent.json'), 'Test JSON content');
+			await fs.promises.writeFile(path.join(sourceDir, 'TestComponent.twig'), 'Test Twig content');
+			await fs.promises.writeFile(path.join(sourceDir, 'TestComponent.vue'), 'Test Vue content');
+			await fs.promises.writeFile(path.join(sourceDir, 'TestComponent.extra'), 'Test Extra content');
+			await fs.promises.writeFile(path.join(sourceDir, 'TestComponent.spec'), 'Test Spec content');
+		} catch (err) {
+			console.error('Error creating the source directory:', err);
+		}
+	});
+
+	// After each test, remove the source and destination files
+	afterEach(async () => {
+		try {
+			const sourceDir = path.join(libraryPath, 'components', componentName);
+			await fs.promises.rmdir(sourceDir, { recursive: true });
+			await removeFile('./inc/acf-blocks/TestComponent.php');
+			await removeFile('./assets/js/blocks/TestComponent.js');
+			await removeFile('./assets/scss/blocks/TestComponent.scss');
+			await removeFile('./acf-json/TestComponent.json');
+			await removeFile('./views/blocks/TestComponent.twig');
+			await removeFile('./assets/vue/blocks/TestComponent.vue');
+			await removeFile('./assets/scss/blocks/TestComponent/TestComponent.extra');
+		} catch (err) {
+			console.error('Error cleaning up the test files:', err);
+		}
+	});
+
+	it('should copy files from source to destination based on the file types', async () => {
+		// Call the function to be tested
+		await updateComponent.copyBlockComponent(componentName);
+
+		// Assert that the destination files exist for each file type
+		const destinationFiles = [
+			'./inc/acf-blocks/TestComponent.php',
+			'./assets/js/blocks/TestComponent.js',
+			'./assets/scss/blocks/TestComponent.scss',
+			'./acf-json/TestComponent.json',
+			'./views/blocks/TestComponent.twig',
+			'./assets/vue/blocks/TestComponent.vue',
+			'./assets/scss/blocks/TestComponent/TestComponent.extra',
+		];
+
+		for (const filePath of destinationFiles) {
+			const fileExists = await accessPromisified(filePath)
+				.then(() => true)
+				.catch(() => false);
+				expect(fileExists).toBe(true);
+		}
+
+		// Assert that the destination files contain the same content as the source files
+		const sourceDir = path.join(libraryPath, 'components', componentName);
+		const fileTypes = ['php', 'js', 'scss', 'json', 'twig', 'vue', 'extra'];
+		for (const fileType of fileTypes) {
+			const sourceContent = await fs.promises.readFile(path.join(sourceDir, `TestComponent.${fileType}`), 'utf-8');
+			const destinationContent = await fs.promises.readFile(path.join(`./${fileType === 'extra' ? 'assets/scss/blocks/TestComponent' : fileType}s/TestComponent.${fileType}`), 'utf-8');
+			expect(destinationContent).toBe(sourceContent);
+		}
+	});
+});

package/__spec__/copyFile.spec.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const updateComponent = require('../update-component');
+
+
+describe('copyFile function', () => {
+	const sourceFilePath = './__spec__/files/source.txt';
+	const destinationFilePath = './__spec__/files/destination.txt';
+
+	// Helper function to delete a file if it exists
+	const deleteFileIfExists = (filePath) => {
+		if (fs.existsSync(filePath)) {
+			fs.unlinkSync(destinationFilePath);
+		}
+	};
+
+	beforeEach(() => {
+		deleteFileIfExists(destinationFilePath);
+		jest.resetModules();
+		jest.clearAllMocks();
+	});
+	afterEach(() => {
+		deleteFileIfExists(destinationFilePath);
+	});
+
+
+	// Test case 1: Ensure the file is copied when destination does not exists
+	test('copies file if it does not exist', async () => {
+		await updateComponent.copyFile(sourceFilePath, destinationFilePath);
+
+		// Wait for a short delay to allow the asynchronous operation to complete
+		await new Promise((resolve) => setTimeout(resolve, 150)); // Adjust the delay time as needed
+
+		expect(fs.existsSync(destinationFilePath)).toBe(true);
+	});
+
+	// Test case 2: Ensure the file is copied even if the destination exists
+	test('overwrite file when destination file already exists', async () => {
+		// Create a dummy destination file to simulate an existing file
+		fs.writeFileSync(destinationFilePath, 'Dummy content Newer');
+
+		await updateComponent.copyFile(sourceFilePath, destinationFilePath);
+		// Wait for a short delay to allow the asynchronous operation to complete
+		await new Promise((resolve) => setTimeout(resolve, 50)); // Adjust the delay time as needed
+
+		// Assert that the destination file still exists after the function call
+		expect(fs.existsSync(destinationFilePath)).toBe(true);
+
+		// get file content
+		const destinationContent = fs.readFileSync(destinationFilePath, 'utf8');
+
+		// content should be 
+		expect(destinationContent).toBe('Dummy content');
+	});
+
+	// Test case 3: Ensure the function handles errors properly
+	test('handles errors when copying the file', async () => {
+		// Create a dummy destination file to simulate an existing file
+		// fs.writeFileSync(destinationFilePath, 'Dummy content');
+		const sourceFilePath = './__spec__/nonexistent_source.txt';
+
+		// Ensure that console.error is called with the error message
+		const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+		
+		await updateComponent.copyFileKeeping(sourceFilePath, destinationFilePath);
+		// Wait for a short delay to allow the asynchronous operation to complete
+		await new Promise((resolve) => setTimeout(resolve, 50)); // Adjust the delay time as needed
+
+		// Assert that console.error was called with the expected error message
+		expect(consoleErrorSpy).toHaveBeenCalled();
+
+		// Restore the original console.error function
+		consoleErrorSpy.mockRestore();
+	});
+
+});

package/__spec__/copyFileKeeping.spec.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const fs = require('fs');
+// const path = require('path');
+const updateComponent = require('../update-component');
+
+describe('copyFileKeeping', () => {
+	const sourceFilePath = './__spec__/files/source.txt';
+	const destinationFilePath = './__spec__/files/destination.txt';
+
+	// Helper function to delete a file if it exists
+	const deleteFileIfExists = (filePath) => {
+		if (fs.existsSync(filePath)) {
+			fs.unlinkSync(destinationFilePath);
+		}
+	};
+
+	beforeEach(() => {
+		deleteFileIfExists(destinationFilePath);
+		jest.resetModules();
+		jest.clearAllMocks();
+	});
+	afterEach(() => {
+		deleteFileIfExists(destinationFilePath);
+	});
+
+	// Test case 1: Ensure the file is copied when destination does not exists
+	test('copies file if it does not exist', async () => {
+		await updateComponent.copyFileKeeping(sourceFilePath, destinationFilePath);
+
+		// Wait for a short delay to allow the asynchronous operation to complete
+		await new Promise((resolve) => setTimeout(resolve, 50)); // Adjust the delay time as needed
+
+		expect(fs.existsSync(destinationFilePath)).toBe(true);
+	});
+
+	// Test case 2: Ensure the file is NOT copied when destination exists
+	test('copies file when destination file already exists', async () => {
+		// Create a dummy destination file to simulate an existing file
+		fs.writeFileSync(destinationFilePath, 'Dummy content Newer');
+
+		await updateComponent.copyFileKeeping(sourceFilePath, destinationFilePath);
+		// Wait for a short delay to allow the asynchronous operation to complete
+		await new Promise((resolve) => setTimeout(resolve, 50)); // Adjust the delay time as needed
+
+		// Assert that the destination file still exists after the function call
+		expect(fs.existsSync(destinationFilePath)).toBe(true);
+
+		// get file content
+		const destinationContent = fs.readFileSync(destinationFilePath, 'utf8');
+
+		expect(destinationContent).toBe('Dummy content Newer');
+	});
+
+	// Test case 3: Ensure the function handles errors properly
+	test('handles errors when copying the file', async () => {
+		// Create a dummy destination file to simulate an existing file
+		// fs.writeFileSync(destinationFilePath, 'Dummy content');
+		const sourceFilePath = './__spec__/nonexistent_source.txt';
+
+		// Ensure that console.error is called with the error message
+		const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+		
+		await updateComponent.copyFileKeeping(sourceFilePath, destinationFilePath);
+		// Wait for a short delay to allow the asynchronous operation to complete
+		await new Promise((resolve) => setTimeout(resolve, 50)); // Adjust the delay time as needed
+
+		// Assert that console.error was called with the expected error message
+		expect(consoleErrorSpy).toHaveBeenCalled();
+
+		// Restore the original console.error function
+		consoleErrorSpy.mockRestore();
+	});
+});

package/__spec__/files/source.txt

@@ -0,0 +1 @@
+Dummy content

package/__spec__/update-all-components.spec.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const glob = require('glob');
+const fs = jest.mock('fs');
+const updateAllComponents = require('../update-all-components');
+
+describe('getComponentsList', () => {
+	afterEach(() => {
+		jest.resetModules(); // Reset all mocked modules after each test
+	});
+
+	it('returns the correct components list when project-components-list.json is found', () => {
+		const projectComponentsList = {
+			"block": [
+				"accordion",
+				"standard-content-v2"
+			],
+			"fields": [
+				"video-standard",
+				"responsive-show-hide"
+			],
+			"admin": [
+				"filter-pages-by-block",
+				"resizable-editor-sidebar"
+			]
+		};
+
+		jest.mock('fs', () => ({
+			existsSync: jest.fn().mockReturnValue(true),
+			readFileSync: jest
+				.fn()
+				.mockReturnValue(JSON.stringify(projectComponentsList)),
+		}));
+
+		const result = updateAllComponents.getComponentsList();
+
+		// random order
+		result.map(m => expect([
+			"block-accordion",
+			"block-standard-content-v2",
+
+			"admin-core-mixins",
+			"admin-core-design-system",
+			"admin-core-generic",
+			"admin-core-critical",
+			"admin-core-functions",
+
+			"admin-filter-pages-by-block",
+			"admin-resizable-editor-sidebar",
+			"fields-video-standard",
+			"fields-responsive-show-hide",
+
+			"admin-core-cta",
+			"admin-core-root-variables",
+			"admin-core-css-sizing-vars",
+			"admin-core-colour-data-config",
+			"admin-core-wordpress-block-editor-preview",
+			"admin-core-editor-cta-style-select",
+			"admin-core-gradient-designer",
+			"admin-core-typography",
+		]).toContain(m));
+	});
+
+	it('returns the correct components list when project-components-list.json is not found', () => {
+		jest.mock('fs', () => ({
+			existsSync: jest.fn().mockReturnValue(false), // Simulate 'project-components-list.json' not existing
+		}));
+
+		jest.mock('glob', () => ({
+			// mock components in the filesystem
+			sync: jest.fn().mockReturnValue([
+				`./node_modules/@pernod-ricard-global-cms/cbl-component-library/components/component1`,
+				`./node_modules/@pernod-ricard-global-cms/cbl-component-library/components/component2`,
+			]),
+		}));
+		const result = updateAllComponents.getComponentsList();
+
+		// random order
+		result.map(m => expect([
+			"admin-core-mixins",
+			"admin-core-design-system",
+			"admin-core-generic",
+			"admin-core-critical",
+			"admin-core-functions",
+
+			"component1",
+			"component2",
+			
+			"admin-core-cta",
+			"admin-core-root-variables",
+			"admin-core-css-sizing-vars",
+			"admin-core-colour-data-config",
+			"admin-core-wordpress-block-editor-preview",
+			"admin-core-editor-cta-style-select",
+			"admin-core-gradient-designer",
+			"admin-core-typography",
+		]).toContain(m));
+	});
+});

package/__spec__/update-component.spec.js

@@ -0,0 +1,165 @@
+'use strict';
+
+// const glob = require('glob');
+const fs = require('fs');
+// const fse = require("fs-extra");
+
+// const path = require('path');
+const updateComponent = require('../update-component');
+
+jest.mock('fs');
+
+describe('getExtension', () => {
+	test('Check getExtension js', () => {
+		const result = updateComponent.getExtension('testing.js')
+		expect(result).toBe('js');
+	});
+
+	test('Check getExtension spec.js', () => {
+		const result = updateComponent.getExtension('testing.spec.js')
+		expect(result).toBe('js');
+	});
+});
+
+describe('getFileType function', () => {
+	it('should return "extra" for filenames ending with "-extra.scss"', () => {
+	  const result = updateComponent.getFileType('styles-extra.scss');
+	  expect(result).toBe('extra');
+	});
+  
+	it('should return "spec" for filenames ending with "spec.js"', () => {
+	  const result = updateComponent.getFileType('test.spec.js');
+	  expect(result).toBe('spec');
+	});
+  
+	it('should return the correct file extension for other filenames', () => {
+	  const result = updateComponent.getFileType('script.js');
+	  expect(result).toBe('js');
+	});
+  
+	it('should return an empty string for filenames without extensions', () => {
+	  const result = updateComponent.getFileType('README');
+	  expect(result).toBe('');
+	});
+});
+
+describe('checkFolder function', () => {
+	beforeEach(() => {
+		jest.resetModules();
+		jest.clearAllMocks();
+	});
+
+	it('should return true for an existing directory', () => {
+		// Mocking fs.existsSync to return true
+		fs.existsSync.mockReturnValue(true);
+		// Mocking fs.statSync to return an object with isDirectory function returning true
+		fs.statSync.mockReturnValue({ isDirectory: () => true });
+	
+		const result = updateComponent.checkFolder('/path/to/existing/folder');
+		expect(result).toBe(true);
+		// Ensure that the fs.existsSync function was called with the correct argument
+		expect(fs.existsSync).toHaveBeenCalledWith('/path/to/existing/folder');
+		// Ensure that the fs.statSync function was called with the correct argument
+		expect(fs.statSync).toHaveBeenCalledWith('/path/to/existing/folder');
+	});
+	
+	it('should return false for a non-existing directory', () => {
+		// Mocking fs.existsSync to return false
+		fs.existsSync.mockReturnValue(false);
+
+		const result = updateComponent.checkFolder('/path/to/non_existing/folder');
+		expect(result).toBe(false);
+		// Ensure that the fs.existsSync function was called with the correct argument
+		expect(fs.existsSync).toHaveBeenCalledWith('/path/to/non_existing/folder');
+		// Ensure that the fs.statSync function was not called (since the folder does not exist)
+		expect(fs.statSync).not.toHaveBeenCalled();
+	});
+	
+	it('should return false for an existing file (not a directory)', () => {
+		// Mocking fs.existsSync to return true
+		fs.existsSync.mockReturnValue(true);
+		// Mocking fs.statSync to return an object with isDirectory function returning false
+		fs.statSync.mockReturnValue({ isDirectory: () => false });
+
+		const result = updateComponent.checkFolder('/path/to/existing/file');
+		expect(result).toBe(false);
+		// Ensure that the fs.existsSync function was called with the correct argument
+		expect(fs.existsSync).toHaveBeenCalledWith('/path/to/existing/file');
+		// Ensure that the fs.statSync function was called with the correct argument
+		expect(fs.statSync).toHaveBeenCalledWith('/path/to/existing/file');
+	});
+});
+
+describe('getProjectName function', () => {
+	beforeEach(() => {
+		jest.resetModules();
+	});
+
+	test('should return the project name from package.json', () => {
+		const projectName = 'Your Project Name';
+		const packageJson = {
+			name: projectName
+		};
+		fs.readFileSync.mockReturnValue(JSON.stringify(packageJson));
+		const result = updateComponent.getProjectName();
+		expect(result).toBe(projectName);
+	});
+
+	test('should capitalize the project name if it does not start with "the"', () => {
+		const projectName = 'your project name';
+		const packageJson = {
+			name: projectName
+		};
+		fs.readFileSync.mockReturnValue(JSON.stringify(packageJson));
+		const result = updateComponent.getProjectName();
+		expect(result).toBe('Your project name');
+	});
+
+	test('should capitalize and prepend "The" to the project name if it starts with "the"', () => {
+		const projectName = 'theglenlivet';
+		const packageJson = {
+			name: projectName
+		};
+		fs.readFileSync.mockReturnValue(JSON.stringify(packageJson));
+		const result = updateComponent.getProjectName();
+		expect(result).toBe('The Glenlivet');
+	});
+
+	test('should return default project name if package.json is not found', () => {
+		fs.readFileSync.mockImplementation(() => {
+			throw new Error('File not found');
+		});
+		// Ensure that console.error is called with the error message
+		const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+		const result = updateComponent.getProjectName();
+		expect(result).toBe('Global Theme');
+		// Assert that console.error was called with the expected error message
+		expect(consoleErrorSpy).toHaveBeenCalled();
+	});
+});
+
+describe('getFileType function', () => {
+	it('should return "extra" for filenames ending with "-extra.scss"', () => {
+		const filename = 'style-extra.scss';
+		expect(updateComponent.getFileType(filename)).toBe('extra');
+	});
+
+	it('should return "spec" for filenames ending with "spec.js"', () => {
+		const filename = 'test.spec.js';
+		expect(updateComponent.getFileType(filename)).toBe('spec');
+	});
+
+	it('should call getExtension for other filenames', () => {
+		const addSpy = jest.spyOn(updateComponent, 'getExtension');
+		// console.log(addSpy)
+		// return
+		const filename = 'example.txt';
+		const result = updateComponent.getFileType(filename);
+		// expect(addSpy).toHaveBeenCalledWith(filename);
+		expect(result).toBe('txt');
+
+		// Don't forget to restore the original 'add' function after the test
+		addSpy.mockRestore();
+	});
+});

package/components/admin-filter-pages-by-block/filter-pages-by-block.php

@@ -0,0 +1,81 @@
+<?php
+// Do not edit this file outside of the component library as otherwise your changes will be lost with future updates.
+
+/**
+ * Adds a dropdown to the admin panel for filtering pages by blocks used on the page.
+ *
+ * @package Global Theme
+ */
+
+/**
+ * Register 'block' as a query variable.
+ *
+ * @param array $vars The existing query variables.
+ * @return array The modified query variables.
+ */
+function register_search_block_query_var( $vars ) {
+	$vars[] = 'block';
+	return $vars;
+}
+add_filter( 'query_vars', 'register_search_block_query_var' );
+
+/**
+ * Add a block types filter dropdown to the admin post list table.
+ *
+ * @param string $post_type The current post type.
+ */
+function add_block_types_filter_dropdown( $post_type ) {
+	// Check if block editor is used for the post type
+	if ( ! use_block_editor_for_post_type( $post_type ) ) {
+		return;
+	}
+
+	// Get all registered block types
+	$block_types = \WP_Block_Type_Registry::get_instance()->get_all_registered();
+
+	$options = array_reduce(
+		$block_types,
+		function ( $options, $block_type ) {
+			// Generate option value based on block type name
+			$val = '<!-- wp:' . str_replace( 'core/', '', $block_type->name ) . ' ';
+
+			// Generate option HTML with selected attribute if it matches the current block query
+			$option_html = sprintf(
+				'<option value="%s" %s>%s</option>',
+				esc_attr( $val ),
+				selected( get_query_var( 'block' ), $val, false ),
+				esc_html( $block_type->title ? $block_type->title : $block_type->name )
+			);
+
+			// Append the option HTML to the options string
+			return $options . $option_html;
+		},
+		''
+	);
+
+	// Output the block filter dropdown
+	echo '<select name="block"><option value="">' . esc_html( __( 'All Block Types', 'Global Theme' ) ) . '</option>' . wp_kses( $options, array( 'option' => array( 'value' => array() ) ) ) . '</select>';
+}
+add_action( 'restrict_manage_posts', 'add_block_types_filter_dropdown' );
+
+/**
+ * Modify the main query before it runs.
+ *
+ * @param WP_Query $query The WP_Query instance.
+ */
+function modify_search_query_for_block( $query ) {
+	// Check if we're in the admin area, main query, and performing a search
+	if ( is_admin() && $query->is_main_query() && $query->is_search() ) {
+		// Get the block query variable and URL decode.
+		$block_query_input = urldecode( get_query_var( 'block' ) );
+		// Sanitize block query input.
+		$block_query = str_replace( '&lt;', '<', sanitize_text_field( $block_query_input ) );
+
+		// Check if the block query variable contains a block pattern
+		if ( strpos( $block_query, '<!-- wp:' ) !== false ) {
+			// Modify the search query to search for the block pattern in the post content
+			$query->set( 's', $block_query );
+		}
+	}
+}
+add_action( 'pre_get_posts', 'modify_search_query_for_block' );