fix: prevent asset conflicts between React and Grid.js versions

Add coexistence checks to all enqueue methods to prevent loading
both React and Grid.js assets simultaneously.

Changes:
- ReactAdmin.php: Only enqueue React assets when ?react=1
- Init.php: Skip Grid.js when React active on admin pages
- Form.php, Coupon.php, Access.php: Restore classic assets when ?react=0
- Customer.php, Product.php, License.php: Add coexistence checks

Now the toggle between Classic and React versions works correctly.

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

node_modules/@wordpress/keycodes/src/index.js

@@ -0,0 +1,443 @@
+/**
+ * Note: The order of the modifier keys in many of the [foo]Shortcut()
+ * functions in this file are intentional and should not be changed. They're
+ * designed to fit with the standard menu keyboard shortcuts shown in the
+ * user's platform.
+ *
+ * For example, on MacOS menu shortcuts will place Shift before Command, but
+ * on Windows Control will usually come first. So don't provide your own
+ * shortcut combos directly to keyboardShortcut().
+ */
+
+/**
+ * WordPress dependencies
+ */
+import { __ } from '@wordpress/i18n';
+
+/**
+ * Internal dependencies
+ */
+import { isAppleOS } from './platform';
+
+/** @typedef {typeof ALT | CTRL | COMMAND | SHIFT } WPModifierPart */
+
+/** @typedef {'primary' | 'primaryShift' | 'primaryAlt' | 'secondary' | 'access' | 'ctrl' | 'alt' | 'ctrlShift' | 'shift' | 'shiftAlt' | 'undefined'} WPKeycodeModifier */
+
+/**
+ * An object of handler functions for each of the possible modifier
+ * combinations. A handler will return a value for a given key.
+ *
+ * @template T
+ *
+ * @typedef {Record<WPKeycodeModifier, T>} WPModifierHandler
+ */
+
+/**
+ * @template T
+ *
+ * @typedef {(character: string, isApple?: () => boolean) => T} WPKeyHandler
+ */
+/** @typedef {(event: import('react').KeyboardEvent<HTMLElement> | KeyboardEvent, character: string, isApple?: () => boolean) => boolean} WPEventKeyHandler */
+
+/** @typedef {( isApple: () => boolean ) => WPModifierPart[]} WPModifier */
+
+/**
+ * Keycode for BACKSPACE key.
+ */
+export const BACKSPACE = 8;
+
+/**
+ * Keycode for TAB key.
+ */
+export const TAB = 9;
+
+/**
+ * Keycode for ENTER key.
+ */
+export const ENTER = 13;
+
+/**
+ * Keycode for ESCAPE key.
+ */
+export const ESCAPE = 27;
+
+/**
+ * Keycode for SPACE key.
+ */
+export const SPACE = 32;
+
+/**
+ * Keycode for PAGEUP key.
+ */
+export const PAGEUP = 33;
+
+/**
+ * Keycode for PAGEDOWN key.
+ */
+export const PAGEDOWN = 34;
+
+/**
+ * Keycode for END key.
+ */
+export const END = 35;
+
+/**
+ * Keycode for HOME key.
+ */
+export const HOME = 36;
+
+/**
+ * Keycode for LEFT key.
+ */
+export const LEFT = 37;
+
+/**
+ * Keycode for UP key.
+ */
+export const UP = 38;
+
+/**
+ * Keycode for RIGHT key.
+ */
+export const RIGHT = 39;
+
+/**
+ * Keycode for DOWN key.
+ */
+export const DOWN = 40;
+
+/**
+ * Keycode for DELETE key.
+ */
+export const DELETE = 46;
+
+/**
+ * Keycode for F10 key.
+ */
+export const F10 = 121;
+
+/**
+ * Keycode for ALT key.
+ */
+export const ALT = 'alt';
+
+/**
+ * Keycode for CTRL key.
+ */
+export const CTRL = 'ctrl';
+
+/**
+ * Keycode for COMMAND/META key.
+ */
+export const COMMAND = 'meta';
+
+/**
+ * Keycode for SHIFT key.
+ */
+export const SHIFT = 'shift';
+
+/**
+ * Keycode for ZERO key.
+ */
+export const ZERO = 48;
+
+export { isAppleOS };
+
+/**
+ * Capitalise the first character of a string.
+ * @param {string} string String to capitalise.
+ * @return {string} Capitalised string.
+ */
+function capitaliseFirstCharacter( string ) {
+	return string.length < 2
+		? string.toUpperCase()
+		: string.charAt( 0 ).toUpperCase() + string.slice( 1 );
+}
+
+/**
+ * Map the values of an object with a specified callback and return the result object.
+ *
+ * @template {{ [s: string]: any; } | ArrayLike<any>} T
+ *
+ * @param {T}                     object Object to map values of.
+ * @param {( value: any ) => any} mapFn  Mapping function
+ *
+ * @return {any} Active modifier constants.
+ */
+function mapValues( object, mapFn ) {
+	return Object.fromEntries(
+		Object.entries( object ).map( ( [ key, value ] ) => [
+			key,
+			mapFn( value ),
+		] )
+	);
+}
+
+/**
+ * Object that contains functions that return the available modifier
+ * depending on platform.
+ *
+ * @type {WPModifierHandler< ( isApple: () => boolean ) => WPModifierPart[]>}
+ */
+export const modifiers = {
+	primary: ( _isApple ) => ( _isApple() ? [ COMMAND ] : [ CTRL ] ),
+	primaryShift: ( _isApple ) =>
+		_isApple() ? [ SHIFT, COMMAND ] : [ CTRL, SHIFT ],
+	primaryAlt: ( _isApple ) =>
+		_isApple() ? [ ALT, COMMAND ] : [ CTRL, ALT ],
+	secondary: ( _isApple ) =>
+		_isApple() ? [ SHIFT, ALT, COMMAND ] : [ CTRL, SHIFT, ALT ],
+	access: ( _isApple ) => ( _isApple() ? [ CTRL, ALT ] : [ SHIFT, ALT ] ),
+	ctrl: () => [ CTRL ],
+	alt: () => [ ALT ],
+	ctrlShift: () => [ CTRL, SHIFT ],
+	shift: () => [ SHIFT ],
+	shiftAlt: () => [ SHIFT, ALT ],
+	undefined: () => [],
+};
+
+/**
+ * An object that contains functions to get raw shortcuts.
+ *
+ * These are intended for user with the KeyboardShortcuts.
+ *
+ * @example
+ * ```js
+ * // Assuming macOS:
+ * rawShortcut.primary( 'm' )
+ * // "meta+m""
+ * ```
+ *
+ * @type {WPModifierHandler<WPKeyHandler<string>>} Keyed map of functions to raw
+ *                                                 shortcuts.
+ */
+export const rawShortcut = mapValues(
+	modifiers,
+	( /** @type {WPModifier} */ modifier ) => {
+		return /** @type {WPKeyHandler<string>} */ (
+			character,
+			_isApple = isAppleOS
+		) => {
+			return [ ...modifier( _isApple ), character.toLowerCase() ].join(
+				'+'
+			);
+		};
+	}
+);
+
+/**
+ * Return an array of the parts of a keyboard shortcut chord for display.
+ *
+ * @example
+ * ```js
+ * // Assuming macOS:
+ * displayShortcutList.primary( 'm' );
+ * // [ "⌘", "M" ]
+ * ```
+ *
+ * @type {WPModifierHandler<WPKeyHandler<string[]>>} Keyed map of functions to
+ *                                                   shortcut sequences.
+ */
+export const displayShortcutList = mapValues(
+	modifiers,
+	( /** @type {WPModifier} */ modifier ) => {
+		return /** @type {WPKeyHandler<string[]>} */ (
+			character,
+			_isApple = isAppleOS
+		) => {
+			const isApple = _isApple();
+			const replacementKeyMap = {
+				[ ALT ]: isApple ? '⌥' : 'Alt',
+				[ CTRL ]: isApple ? '⌃' : 'Ctrl', // Make sure ⌃ is the U+2303 UP ARROWHEAD unicode character and not the caret character.
+				[ COMMAND ]: '⌘',
+				[ SHIFT ]: isApple ? '⇧' : 'Shift',
+			};
+
+			const modifierKeys = modifier( _isApple ).reduce(
+				( accumulator, key ) => {
+					const replacementKey = replacementKeyMap[ key ] ?? key;
+					// If on the Mac, adhere to platform convention and don't show plus between keys.
+					if ( isApple ) {
+						return [ ...accumulator, replacementKey ];
+					}
+
+					return [ ...accumulator, replacementKey, '+' ];
+				},
+				/** @type {string[]} */ ( [] )
+			);
+
+			return [ ...modifierKeys, capitaliseFirstCharacter( character ) ];
+		};
+	}
+);
+
+/**
+ * An object that contains functions to display shortcuts.
+ *
+ * @example
+ * ```js
+ * // Assuming macOS:
+ * displayShortcut.primary( 'm' );
+ * // "⌘M"
+ * ```
+ *
+ * @type {WPModifierHandler<WPKeyHandler<string>>} Keyed map of functions to
+ *                                                 display shortcuts.
+ */
+export const displayShortcut = mapValues(
+	displayShortcutList,
+	( /** @type {WPKeyHandler<string[]>} */ shortcutList ) => {
+		return /** @type {WPKeyHandler<string>} */ (
+			character,
+			_isApple = isAppleOS
+		) => shortcutList( character, _isApple ).join( '' );
+	}
+);
+
+/**
+ * An object that contains functions to return an aria label for a keyboard
+ * shortcut.
+ *
+ * @example
+ * ```js
+ * // Assuming macOS:
+ * shortcutAriaLabel.primary( '.' );
+ * // "Command + Period"
+ * ```
+ *
+ * @type {WPModifierHandler<WPKeyHandler<string>>} Keyed map of functions to
+ *                                                 shortcut ARIA labels.
+ */
+export const shortcutAriaLabel = mapValues(
+	modifiers,
+	( /** @type {WPModifier} */ modifier ) => {
+		return /** @type {WPKeyHandler<string>} */ (
+			character,
+			_isApple = isAppleOS
+		) => {
+			const isApple = _isApple();
+			/** @type {Record<string,string>} */
+			const replacementKeyMap = {
+				[ SHIFT ]: 'Shift',
+				[ COMMAND ]: isApple ? 'Command' : 'Control',
+				[ CTRL ]: 'Control',
+				[ ALT ]: isApple ? 'Option' : 'Alt',
+				/* translators: comma as in the character ',' */
+				',': __( 'Comma' ),
+				/* translators: period as in the character '.' */
+				'.': __( 'Period' ),
+				/* translators: backtick as in the character '`' */
+				'`': __( 'Backtick' ),
+				/* translators: tilde as in the character '~' */
+				'~': __( 'Tilde' ),
+			};
+
+			return [ ...modifier( _isApple ), character ]
+				.map( ( key ) =>
+					capitaliseFirstCharacter( replacementKeyMap[ key ] ?? key )
+				)
+				.join( isApple ? ' ' : ' + ' );
+		};
+	}
+);
+
+/**
+ * From a given KeyboardEvent, returns an array of active modifier constants for
+ * the event.
+ *
+ * @param {import('react').KeyboardEvent<HTMLElement> | KeyboardEvent} event Keyboard event.
+ *
+ * @return {Array<WPModifierPart>} Active modifier constants.
+ */
+function getEventModifiers( event ) {
+	return /** @type {WPModifierPart[]} */ ( [
+		ALT,
+		CTRL,
+		COMMAND,
+		SHIFT,
+	] ).filter(
+		( key ) =>
+			event[
+				/** @type {'altKey' | 'ctrlKey' | 'metaKey' | 'shiftKey'} */ (
+					`${ key }Key`
+				)
+			]
+	);
+}
+
+/**
+ * An object that contains functions to check if a keyboard event matches a
+ * predefined shortcut combination.
+ *
+ * @example
+ * ```js
+ * // Assuming an event for ⌘M key press:
+ * isKeyboardEvent.primary( event, 'm' );
+ * // true
+ * ```
+ *
+ * @type {WPModifierHandler<WPEventKeyHandler>} Keyed map of functions
+ *                                                       to match events.
+ */
+export const isKeyboardEvent = mapValues(
+	modifiers,
+	( /** @type {WPModifier} */ getModifiers ) => {
+		return /** @type {WPEventKeyHandler} */ (
+			event,
+			character,
+			_isApple = isAppleOS
+		) => {
+			const mods = getModifiers( _isApple );
+			const eventMods = getEventModifiers( event );
+			/** @type {Record<string,string>} */
+			const replacementWithShiftKeyMap = {
+				Comma: ',',
+				Backslash: '\\',
+				// Windows returns `\` for both IntlRo and IntlYen.
+				IntlRo: '\\',
+				IntlYen: '\\',
+			};
+
+			const modsDiff = mods.filter(
+				( mod ) => ! eventMods.includes( mod )
+			);
+			const eventModsDiff = eventMods.filter(
+				( mod ) => ! mods.includes( mod )
+			);
+
+			if ( modsDiff.length > 0 || eventModsDiff.length > 0 ) {
+				return false;
+			}
+
+			let key = event.key.toLowerCase();
+
+			if ( ! character ) {
+				return mods.includes( /** @type {WPModifierPart} */ ( key ) );
+			}
+
+			if ( event.altKey && character.length === 1 ) {
+				key = String.fromCharCode( event.keyCode ).toLowerCase();
+			}
+
+			// `event.key` returns the value of the key pressed, taking into the state of
+			// modifier keys such as `Shift`. If the shift key is pressed, a different
+			// value may be returned depending on the keyboard layout. It is necessary to
+			// convert to the physical key value that don't take into account keyboard
+			// layout or modifier key state.
+			if (
+				event.shiftKey &&
+				character.length === 1 &&
+				replacementWithShiftKeyMap[ event.code ]
+			) {
+				key = replacementWithShiftKeyMap[ event.code ];
+			}
+
+			// For backwards compatibility.
+			if ( character === 'del' ) {
+				character = 'delete';
+			}
+
+			return key === character.toLowerCase();
+		};
+	}
+);

node_modules/@wordpress/keycodes/src/platform.js

@@ -0,0 +1,23 @@
+/**
+ * Return true if platform is MacOS.
+ *
+ * @param {Window?} _window window object by default; used for DI testing.
+ *
+ * @return {boolean} True if MacOS; false otherwise.
+ */
+export function isAppleOS( _window = null ) {
+	if ( ! _window ) {
+		if ( typeof window === 'undefined' ) {
+			return false;
+		}
+
+		_window = window;
+	}
+
+	const { platform } = _window.navigator;
+
+	return (
+		platform.indexOf( 'Mac' ) !== -1 ||
+		[ 'iPad', 'iPhone' ].includes( platform )
+	);
+}

node_modules/@wordpress/keycodes/src/platform.native.js

@@ -0,0 +1,13 @@
+/**
+ * External dependencies
+ */
+import { Platform } from 'react-native';
+
+/**
+ * Return true if platform is iOS.
+ *
+ * @return {boolean} True if iOS; false otherwise.
+ */
+export function isAppleOS() {
+	return Platform.OS === 'ios';
+}

node_modules/@wordpress/keycodes/src/test/index.js

@@ -0,0 +1,576 @@
+/**
+ * Internal dependencies
+ */
+import {
+	displayShortcutList,
+	displayShortcut,
+	rawShortcut,
+	shortcutAriaLabel,
+	isKeyboardEvent,
+} from '../';
+
+const isAppleOSFalse = () => false;
+const isAppleOSTrue = () => true;
+
+describe( 'displayShortcutList', () => {
+	describe( 'primary', () => {
+		it( 'should output [ Ctrl, +, M ] on Windows', () => {
+			const shortcut = displayShortcutList.primary( 'm', isAppleOSFalse );
+			expect( shortcut ).toEqual( [ 'Ctrl', '+', 'M' ] );
+		} );
+
+		it( 'should output [ ⌘, M ] on MacOS', () => {
+			const shortcut = displayShortcutList.primary( 'm', isAppleOSTrue );
+			expect( shortcut ).toEqual( [ '⌘', 'M' ] );
+		} );
+
+		it( 'outputs [ ⌘, Del ] on MacOS (works for multiple character keys)', () => {
+			const shortcut = displayShortcutList.primary(
+				'del',
+				isAppleOSTrue
+			);
+			expect( shortcut ).toEqual( [ '⌘', 'Del' ] );
+		} );
+	} );
+
+	describe( 'primaryShift', () => {
+		it( 'should output [ Ctrl, +, Shift, +, M ] on Windows', () => {
+			const shortcut = displayShortcutList.primaryShift(
+				'm',
+				isAppleOSFalse
+			);
+			expect( shortcut ).toEqual( [ 'Ctrl', '+', 'Shift', '+', 'M' ] );
+		} );
+
+		it( 'should output [ ⇧, ⌘, M ] on MacOS', () => {
+			const shortcut = displayShortcutList.primaryShift(
+				'm',
+				isAppleOSTrue
+			);
+			expect( shortcut ).toEqual( [ '⇧', '⌘', 'M' ] );
+		} );
+
+		it( 'outputs [ ⇧, ⌘, Del ] on MacOS (works for multiple character keys)', () => {
+			const shortcut = displayShortcutList.primaryShift(
+				'del',
+				isAppleOSTrue
+			);
+			expect( shortcut ).toEqual( [ '⇧', '⌘', 'Del' ] );
+		} );
+	} );
+
+	describe( 'secondary', () => {
+		it( 'should output [ Ctrl, +, Shift, +, Alt ] text on Windows', () => {
+			const shortcut = displayShortcutList.secondary(
+				'm',
+				isAppleOSFalse
+			);
+			expect( shortcut ).toEqual( [
+				'Ctrl',
+				'+',
+				'Shift',
+				'+',
+				'Alt',
+				'+',
+				'M',
+			] );
+		} );
+
+		it( 'should output [ ⇧, ⌥, ⌘, M ] on MacOS', () => {
+			const shortcut = displayShortcutList.secondary(
+				'm',
+				isAppleOSTrue
+			);
+			expect( shortcut ).toEqual( [ '⇧', '⌥', '⌘', 'M' ] );
+		} );
+	} );
+
+	describe( 'access', () => {
+		it( 'should output [ Shift, +, Alt, +, M ] on Windows', () => {
+			const shortcut = displayShortcutList.access( 'm', isAppleOSFalse );
+			expect( shortcut ).toEqual( [ 'Shift', '+', 'Alt', '+', 'M' ] );
+		} );
+
+		it( 'should output [⌃, ⌥, M ] on MacOS', () => {
+			const shortcut = displayShortcutList.access( 'm', isAppleOSTrue );
+			expect( shortcut ).toEqual( [ '⌃', '⌥', 'M' ] );
+		} );
+	} );
+} );
+
+describe( 'displayShortcut', () => {
+	describe( 'primary', () => {
+		it( 'should output Control text on Windows', () => {
+			const shortcut = displayShortcut.primary( 'm', isAppleOSFalse );
+			expect( shortcut ).toEqual( 'Ctrl+M' );
+		} );
+
+		it( 'should output command symbol on MacOS', () => {
+			const shortcut = displayShortcut.primary( 'm', isAppleOSTrue );
+			expect( shortcut ).toEqual( '⌘M' );
+		} );
+
+		it( 'outputs command Del on MacOS (works for multiple character keys)', () => {
+			const shortcut = displayShortcut.primary( 'del', isAppleOSTrue );
+			expect( shortcut ).toEqual( '⌘Del' );
+		} );
+	} );
+
+	describe( 'primaryShift', () => {
+		it( 'should output Ctrl+Shift text on Windows', () => {
+			const shortcut = displayShortcut.primaryShift(
+				'm',
+				isAppleOSFalse
+			);
+			expect( shortcut ).toEqual( 'Ctrl+Shift+M' );
+		} );
+
+		it( 'should output shift+command symbols on MacOS', () => {
+			const shortcut = displayShortcut.primaryShift( 'm', isAppleOSTrue );
+			expect( shortcut ).toEqual( '⇧⌘M' );
+		} );
+
+		it( 'outputs ⇧⌘Del on MacOS (works for multiple character keys)', () => {
+			const shortcut = displayShortcut.primaryShift(
+				'del',
+				isAppleOSTrue
+			);
+			expect( shortcut ).toEqual( '⇧⌘Del' );
+		} );
+	} );
+
+	describe( 'secondary', () => {
+		it( 'should output Ctrl+Shift+Alt text on Windows', () => {
+			const shortcut = displayShortcut.secondary( 'm', isAppleOSFalse );
+			expect( shortcut ).toEqual( 'Ctrl+Shift+Alt+M' );
+		} );
+
+		it( 'should output ⇧+option+command symbols on MacOS', () => {
+			const shortcut = displayShortcut.secondary( 'm', isAppleOSTrue );
+			expect( shortcut ).toEqual( '⇧⌥⌘M' );
+		} );
+	} );
+
+	describe( 'access', () => {
+		it( 'should output Shift+Alt text on Windows', () => {
+			const shortcut = displayShortcut.access( 'm', isAppleOSFalse );
+			expect( shortcut ).toEqual( 'Shift+Alt+M' );
+		} );
+
+		it( 'should output control+option symbols on MacOS', () => {
+			const shortcut = displayShortcut.access( 'm', isAppleOSTrue );
+			expect( shortcut ).toEqual( '⌃⌥M' );
+		} );
+	} );
+} );
+
+describe( 'shortcutAriaLabel', () => {
+	describe( 'primary', () => {
+		it( 'should output "Control + Period" on Windows', () => {
+			const shortcut = shortcutAriaLabel.primary( '.', isAppleOSFalse );
+			expect( shortcut ).toEqual( 'Control + Period' );
+		} );
+
+		it( 'should output "Command Period" on Windows', () => {
+			const shortcut = shortcutAriaLabel.primary( '.', isAppleOSTrue );
+			expect( shortcut ).toEqual( 'Command Period' );
+		} );
+	} );
+
+	describe( 'primaryShift', () => {
+		it( 'should output "Control + Shift + Period" on Windows', () => {
+			const shortcut = shortcutAriaLabel.primaryShift(
+				'.',
+				isAppleOSFalse
+			);
+			expect( shortcut ).toEqual( 'Control + Shift + Period' );
+		} );
+
+		it( 'should output "Shift Command Period" on MacOS', () => {
+			const shortcut = shortcutAriaLabel.primaryShift(
+				'.',
+				isAppleOSTrue
+			);
+			expect( shortcut ).toEqual( 'Shift Command Period' );
+		} );
+	} );
+
+	describe( 'secondary', () => {
+		it( 'should output "Control + Shift + Alt + Period" on Windows', () => {
+			const shortcut = shortcutAriaLabel.secondary( '.', isAppleOSFalse );
+			expect( shortcut ).toEqual( 'Control + Shift + Alt + Period' );
+		} );
+
+		it( 'should output "Shift Option Command Period" on MacOS', () => {
+			const shortcut = shortcutAriaLabel.secondary( '.', isAppleOSTrue );
+			expect( shortcut ).toEqual( 'Shift Option Command Period' );
+		} );
+	} );
+
+	describe( 'access', () => {
+		it( 'should output "Shift + Alt + Period" on Windows', () => {
+			const shortcut = shortcutAriaLabel.access( '.', isAppleOSFalse );
+			expect( shortcut ).toEqual( 'Shift + Alt + Period' );
+		} );
+
+		it( 'should output "Control Option Period" on MacOS', () => {
+			const shortcut = shortcutAriaLabel.access( '.', isAppleOSTrue );
+			expect( shortcut ).toEqual( 'Control Option Period' );
+		} );
+	} );
+} );
+
+describe( 'rawShortcut', () => {
+	describe( 'primary', () => {
+		it( 'should output ctrl on Windows', () => {
+			const shortcut = rawShortcut.primary( 'm', isAppleOSFalse );
+			expect( shortcut ).toEqual( 'ctrl+m' );
+		} );
+
+		it( 'should output meta on MacOS', () => {
+			const shortcut = rawShortcut.primary( 'm', isAppleOSTrue );
+			expect( shortcut ).toEqual( 'meta+m' );
+		} );
+	} );
+
+	describe( 'primaryShift', () => {
+		it( 'should output ctrl+shift on Windows', () => {
+			const shortcut = rawShortcut.primaryShift( 'm', isAppleOSFalse );
+			expect( shortcut ).toEqual( 'ctrl+shift+m' );
+		} );
+
+		it( 'should output shift+meta on MacOS', () => {
+			const shortcut = rawShortcut.primaryShift( 'm', isAppleOSTrue );
+			expect( shortcut ).toEqual( 'shift+meta+m' );
+		} );
+	} );
+
+	describe( 'secondary', () => {
+		it( 'should output ctrl+shift+alt on Windows', () => {
+			const shortcut = rawShortcut.secondary( 'm', isAppleOSFalse );
+			expect( shortcut ).toEqual( 'ctrl+shift+alt+m' );
+		} );
+
+		it( 'should output shift+alt+meta on MacOS', () => {
+			const shortcut = rawShortcut.secondary( 'm', isAppleOSTrue );
+			expect( shortcut ).toEqual( 'shift+alt+meta+m' );
+		} );
+	} );
+
+	describe( 'access', () => {
+		it( 'should output shift+alt on Windows', () => {
+			const shortcut = rawShortcut.access( 'm', isAppleOSFalse );
+			expect( shortcut ).toEqual( 'shift+alt+m' );
+		} );
+
+		it( 'should output ctrl+alt on MacOS', () => {
+			const shortcut = rawShortcut.access( 'm', isAppleOSTrue );
+			expect( shortcut ).toEqual( 'ctrl+alt+m' );
+		} );
+	} );
+} );
+
+describe( 'isKeyboardEvent', () => {
+	afterEach( () => {
+		while ( document.body.firstChild ) {
+			document.body.removeChild( document.body.firstChild );
+		}
+	} );
+
+	function keyPress( target, modifiers ) {
+		[ 'keydown', 'keypress', 'keyup' ].forEach( ( eventName ) => {
+			const event = new window.KeyboardEvent( eventName, {
+				...modifiers,
+				bubbles: true,
+				keyCode: modifiers.key.charCodeAt( 0 ),
+			} );
+			target.dispatchEvent( event );
+		} );
+	}
+
+	function attachEventListeners( eventHandler ) {
+		const attachNode = document.createElement( 'div' );
+		document.body.appendChild( attachNode );
+
+		[ 'keydown', 'keypress', 'keyup' ].forEach( ( eventName ) => {
+			attachNode.addEventListener( eventName, eventHandler );
+		} );
+
+		return attachNode;
+	}
+
+	it( 'returns false for a superset of modifiers', () => {
+		expect.assertions( 3 );
+		const attachNode = attachEventListeners( ( event ) => {
+			expect(
+				isKeyboardEvent.primary( event, 'm', isAppleOSFalse )
+			).toBe( false );
+		} );
+
+		keyPress( attachNode, {
+			ctrlKey: true,
+			shiftKey: true,
+			key: 'm',
+		} );
+	} );
+
+	describe( 'primary', () => {
+		it( 'should identify modifier key when Ctrl is pressed', () => {
+			expect.assertions( 3 );
+			const attachNode = attachEventListeners( ( event ) => {
+				expect(
+					isKeyboardEvent.primary( event, undefined, isAppleOSFalse )
+				).toBe( true );
+			} );
+
+			keyPress( attachNode, {
+				ctrlKey: true,
+				key: 'Ctrl',
+			} );
+		} );
+
+		it( 'should identify modifier key when ⌘ is pressed', () => {
+			expect.assertions( 3 );
+			const attachNode = attachEventListeners( ( event ) => {
+				expect(
+					isKeyboardEvent.primary( event, undefined, isAppleOSTrue )
+				).toBe( true );
+			} );
+
+			keyPress( attachNode, {
+				metaKey: true,
+				key: 'Meta',
+			} );
+		} );
+
+		it( 'should identify modifier key when Ctrl + M is pressed', () => {
+			expect.assertions( 3 );
+			const attachNode = attachEventListeners( ( event ) => {
+				expect(
+					isKeyboardEvent.primary( event, 'm', isAppleOSFalse )
+				).toBe( true );
+			} );
+
+			keyPress( attachNode, {
+				ctrlKey: true,
+				key: 'm',
+			} );
+		} );
+
+		it( 'should identify modifier key when ⌘M is pressed', () => {
+			expect.assertions( 3 );
+			const attachNode = attachEventListeners( ( event ) => {
+				expect(
+					isKeyboardEvent.primary( event, 'm', isAppleOSTrue )
+				).toBe( true );
+			} );
+
+			keyPress( attachNode, {
+				metaKey: true,
+				key: 'm',
+			} );
+		} );
+	} );
+
+	describe( 'primaryShift', () => {
+		it( 'should identify modifier key when Shift + Ctrl is pressed', () => {
+			expect.assertions( 3 );
+			const attachNode = attachEventListeners( ( event ) => {
+				expect(
+					isKeyboardEvent.primaryShift(
+						event,
+						undefined,
+						isAppleOSFalse
+					)
+				).toBe( true );
+			} );
+
+			keyPress( attachNode, {
+				ctrlKey: true,
+				shiftKey: true,
+				key: 'Ctrl',
+			} );
+		} );
+
+		it( 'should identify modifier key when ⇧⌘ is pressed', () => {
+			expect.assertions( 3 );
+			const attachNode = attachEventListeners( ( event ) => {
+				expect(
+					isKeyboardEvent.primaryShift(
+						event,
+						undefined,
+						isAppleOSTrue
+					)
+				).toBe( true );
+			} );
+
+			keyPress( attachNode, {
+				metaKey: true,
+				shiftKey: true,
+				key: 'Meta',
+			} );
+		} );
+
+		it( 'should identify modifier key when Shift + Ctrl + M is pressed', () => {
+			expect.assertions( 3 );
+			const attachNode = attachEventListeners( ( event ) => {
+				expect(
+					isKeyboardEvent.primaryShift( event, 'm', isAppleOSFalse )
+				).toBe( true );
+			} );
+
+			keyPress( attachNode, {
+				ctrlKey: true,
+				shiftKey: true,
+				key: 'm',
+			} );
+		} );
+
+		it( 'should identify modifier key when ⇧⌘M is pressed', () => {
+			expect.assertions( 3 );
+			const attachNode = attachEventListeners( ( event ) => {
+				expect(
+					isKeyboardEvent.primaryShift( event, 'm', isAppleOSTrue )
+				).toBe( true );
+			} );
+
+			keyPress( attachNode, {
+				metaKey: true,
+				shiftKey: true,
+				key: 'm',
+			} );
+		} );
+	} );
+
+	describe( 'secondary', () => {
+		it( 'should identify modifier key when Shift + Alt + Ctrl is pressed', () => {
+			expect.assertions( 3 );
+			const attachNode = attachEventListeners( ( event ) => {
+				expect(
+					isKeyboardEvent.secondary(
+						event,
+						undefined,
+						isAppleOSFalse
+					)
+				).toBe( true );
+			} );
+
+			keyPress( attachNode, {
+				ctrlKey: true,
+				shiftKey: true,
+				altKey: true,
+				key: 'Ctrl',
+			} );
+		} );
+
+		it( 'should identify modifier key when ⇧⌥⌘ is pressed', () => {
+			expect.assertions( 3 );
+			const attachNode = attachEventListeners( ( event ) => {
+				expect(
+					isKeyboardEvent.secondary( event, undefined, isAppleOSTrue )
+				).toBe( true );
+			} );
+
+			keyPress( attachNode, {
+				metaKey: true,
+				shiftKey: true,
+				altKey: true,
+				key: 'Meta',
+			} );
+		} );
+
+		it( 'should identify modifier key when Shift + Ctrl + ALt + M is pressed', () => {
+			expect.assertions( 3 );
+			const attachNode = attachEventListeners( ( event ) => {
+				expect(
+					isKeyboardEvent.secondary( event, 'm', isAppleOSFalse )
+				).toBe( true );
+			} );
+
+			keyPress( attachNode, {
+				ctrlKey: true,
+				shiftKey: true,
+				altKey: true,
+				key: 'm',
+			} );
+		} );
+
+		it( 'should identify modifier key when ⇧⌥⌘M is pressed', () => {
+			expect.assertions( 3 );
+			const attachNode = attachEventListeners( ( event ) => {
+				expect(
+					isKeyboardEvent.secondary( event, 'm', isAppleOSTrue )
+				).toBe( true );
+			} );
+
+			keyPress( attachNode, {
+				metaKey: true,
+				shiftKey: true,
+				altKey: true,
+				key: 'm',
+			} );
+		} );
+	} );
+
+	describe( 'access', () => {
+		it( 'should identify modifier key when Shift + Alt is pressed', () => {
+			expect.assertions( 3 );
+			const attachNode = attachEventListeners( ( event ) => {
+				expect(
+					isKeyboardEvent.access( event, undefined, isAppleOSFalse )
+				).toBe( true );
+			} );
+
+			keyPress( attachNode, {
+				shiftKey: true,
+				altKey: true,
+				key: 'Alt',
+			} );
+		} );
+
+		it( 'should identify modifier key when Ctrl + ⌥ is pressed', () => {
+			expect.assertions( 3 );
+			const attachNode = attachEventListeners( ( event ) => {
+				expect(
+					isKeyboardEvent.access( event, undefined, isAppleOSTrue )
+				).toBe( true );
+			} );
+
+			keyPress( attachNode, {
+				ctrlKey: true,
+				altKey: true,
+				key: 'Alt',
+			} );
+		} );
+
+		it( 'should identify modifier key when Shift + Alt + M is pressed', () => {
+			expect.assertions( 3 );
+			const attachNode = attachEventListeners( ( event ) => {
+				expect(
+					isKeyboardEvent.access( event, 'm', isAppleOSFalse )
+				).toBe( true );
+			} );
+
+			keyPress( attachNode, {
+				shiftKey: true,
+				altKey: true,
+				key: 'm',
+			} );
+		} );
+
+		it( 'should identify modifier key when Ctrl + ⌥M is pressed', () => {
+			expect.assertions( 3 );
+			const attachNode = attachEventListeners( ( event ) => {
+				expect(
+					isKeyboardEvent.access( event, 'm', isAppleOSTrue )
+				).toBe( true );
+			} );
+
+			keyPress( attachNode, {
+				ctrlKey: true,
+				altKey: true,
+				key: 'm',
+			} );
+		} );
+	} );
+} );

node_modules/@wordpress/keycodes/src/test/platform.js

@@ -0,0 +1,54 @@
+/**
+ * Internal dependencies
+ */
+import { isAppleOS } from '../platform';
+
+describe( 'isAppleOS helper', () => {
+	it( 'should identify anything with "Mac" in it as Apple OS', () => {
+		expect( isAppleOS( { navigator: { platform: 'Mac' } } ) ).toEqual(
+			true
+		);
+		expect( isAppleOS( { navigator: { platform: 'MacIntel' } } ) ).toEqual(
+			true
+		);
+	} );
+
+	it( 'should identify "iPad" as Apple OS', () => {
+		expect( isAppleOS( { navigator: { platform: 'iPad' } } ) ).toEqual(
+			true
+		);
+	} );
+
+	it( 'should identify "iPhone" as Apple OS', () => {
+		expect( isAppleOS( { navigator: { platform: 'iPhone' } } ) ).toEqual(
+			true
+		);
+	} );
+
+	it( 'should not identify Windows as MacOS', () => {
+		expect( isAppleOS( { navigator: { platform: 'Windows' } } ) ).toEqual(
+			false
+		);
+		expect( isAppleOS( { navigator: { platform: 'Win' } } ) ).toEqual(
+			false
+		);
+	} );
+
+	it( 'should not identify *NIX as MacOS', () => {
+		expect( isAppleOS( { navigator: { platform: 'Linux' } } ) ).toEqual(
+			false
+		);
+		expect( isAppleOS( { navigator: { platform: 'Unix' } } ) ).toEqual(
+			false
+		);
+	} );
+
+	it( 'should not identify other cases as MacOS', () => {
+		expect( isAppleOS( { navigator: { platform: 'MAC' } } ) ).toEqual(
+			false
+		);
+		expect( isAppleOS( { navigator: { platform: 'mac' } } ) ).toEqual(
+			false
+		);
+	} );
+} );