@total_onion/onion-library 3.2.0 → 3.2.1

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

@@ -0,0 +1,38 @@
+# 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: [published]
+    branches:
+      - master
+permissions:
+  id-token: write  # Required for OIDC
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+      # Ensure npm 11.5.1 or later is installed
+      - name: Update npm
+        run: npm install -g npm@latest
+      - run: npm ci
+
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          registry-url: https://registry.npmjs.org/
+      - run: npm publish

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/__spec__/copyBlockComponent.spec.js

@@ -0,0 +1,94 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+
+// Import the function to be tested
+import updateComponent from '../update-component.js';
+
+// 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';
+
+import fs from 'node:fs';
+import path from 'node:path';
+import updateComponent from '../update-component.js';
+
+
+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';
+
+import fs from 'node:fs';
+// import path from 'node:path';
+import updateComponent from '../update-component.js';
+
+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';
+
+import * as glob from 'glob';
+const fs = jest.mock('fs');
+import updateAllComponents from '../update-all-components.js';
+
+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';
+
+// import * as glob from 'glob';
+import fs from 'node:fs';
+// const fse = require("fs-extra");
+
+// import path from 'node:path';
+import updateComponent from '../update-component.js';
+
+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/assembleAssetList.js

@@ -0,0 +1,69 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {globSync} from 'glob';
+
+const dynamicEntryPointsJs = globSync(`./components/block-*/*-v3.js`).map(
+	(filePath) => {
+		const assetKey = path.basename(filePath, '.js');
+		return assetKey;
+	}
+);
+const dynamicEntryPointsJsV4 = globSync(`./components/block-*/*-v4.js`).map(
+	(filePath) => {
+		const assetKey = path.basename(filePath, '.js');
+		return assetKey;
+	}
+);
+const dynamicEntryPointsScss = globSync(`./components/block-*/*-v3.scss`).map(
+	(filePath) => {
+		const assetKey = path.basename(filePath, '.js');
+		return assetKey;
+	}
+);
+const dynamicEntryPointsCss = globSync(`./components/block-*/*-v4.css`).map(
+	(filePath) => {
+		const assetKey = path.basename(filePath, '.js');
+		return assetKey;
+	}
+);
+const assetArrayJs = dynamicEntryPointsJs.map((entry) => {
+	return `./components/block-${entry}/${entry}.js`;
+});
+const assetArrayJsV4 = dynamicEntryPointsJsV4.map((entry) => {
+	return `./components/block-${entry}/${entry}.js`;
+});
+
+const assetArrayScss = dynamicEntryPointsScss.map((entry) => {
+	let filename = entry.replace('.scss', '');
+	return `./components/block-${filename}/${filename}.scss`;
+});
+const assetArrayCss = dynamicEntryPointsCss.map((entry) => {
+	let filename = entry.replace('.css', '');
+	return `./components/block-${filename}/${filename}.css`;
+});
+
+// Create the directory path for the target file
+const jsModulePath = path.join('./public');
+const jsAssetsFilePath = path.join(jsModulePath, 'assetList.mjs');
+
+// Create directories if they don't exist
+fs.mkdirSync(jsModulePath, {recursive: true});
+
+// Write the initial content to the target file
+fs.writeFileSync(jsAssetsFilePath, '// This file is auto-generated.\n');
+
+// Create directories if they don't exist
+const dirPath = path.dirname(jsAssetsFilePath);
+fs.mkdirSync(dirPath, {recursive: true});
+
+const data = `
+const dynamicAssets = ${JSON.stringify([
+	...assetArrayScss,
+	...assetArrayCss,
+	...assetArrayJs,
+	...assetArrayJsV4
+])};
+export default dynamicAssets;
+`;
+
+fs.writeFileSync(jsAssetsFilePath, data);

package/breakpoints.scss

@@ -0,0 +1,6 @@
+//Breakpoints
+$mobile: 375px;
+$tabPortrait: 768px;
+$tabLandscape: 1024px;
+$desktop: 1440px;
+$desktop-fullhd: 1920px;

package/build-library.js

@@ -0,0 +1,4 @@
+import('./assembleAssetList.js');
+import('./createDynamicBlockScss-v3.js');
+import('./createJsAssets-v3.js');
+import('./esbuild.mjs');

package/checkBuildAssets.js

@@ -0,0 +1,17 @@
+import 'dotenv/config';
+import fs from 'node:fs';
+import {fork} from 'node:child_process';
+
+const themePath = process.env.THEME_PATH || 'web/wp-content/themes/global-theme';
+
+const paths = {
+	createJsAssets: `${themePath}/assets/js/modules/jsAssets.js`,
+	createPreviewScss: `${themePath}/assets/scss/modules/dynamicBlocksPreview.scss`,
+};
+
+Object.keys(paths).forEach((key) => {
+	if (!fs.existsSync(paths[key])) {
+		console.log(`creating missing assets with ${key}`);
+		fork(`./node_modules/@pernod-ricard-global-cms/jsbuildutils/${key}.js`);
+	}
+});

package/components/block-accent-image-v3/accent-image-v3.js

@@ -0,0 +1,7 @@
+export default function accentimagev3Js ( options = {} ) {
+	try {
+		const { block } = options;
+	} catch ( error ) {
+		console.error( error );
+	}
+}