Expose registerHook and runHooks as official public APIs

addon-test-support/@ember/test-helpers/dom/blur.ts

@@ -4,7 +4,7 @@ import settled from '../settled';
 import Target from './-target';
 import { log } from '@ember/test-helpers/dom/-logging';
 import isFocusable from './-is-focusable';
-import { runHooks, registerHook } from '../-internal/helper-hooks';
+import { runHooks, registerHook } from '../helper-hooks';
 
 registerHook('blur', 'start', (target: Target) => {
   log('blur', target);

addon-test-support/@ember/test-helpers/dom/click.ts

@@ -5,7 +5,7 @@ import settled from '../settled';
 import isFormControl from './-is-form-control';
 import Target, { isWindow } from './-target';
 import { log } from '@ember/test-helpers/dom/-logging';
-import { runHooks, registerHook } from '../-internal/helper-hooks';
+import { runHooks, registerHook } from '../helper-hooks';
 
 const PRIMARY_BUTTON = 1;
 const MAIN_BUTTON_PRESSED = 0;

addon-test-support/@ember/test-helpers/dom/double-click.ts

@@ -6,7 +6,7 @@ import { DEFAULT_CLICK_OPTIONS } from './click';
 import Target, { isWindow } from './-target';
 import { log } from '@ember/test-helpers/dom/-logging';
 import isFormControl from './-is-form-control';
-import { runHooks, registerHook } from '../-internal/helper-hooks';
+import { runHooks, registerHook } from '../helper-hooks';
 
 registerHook('doubleClick', 'start', (target: Target) => {
   log('doubleClick', target);

addon-test-support/@ember/test-helpers/dom/fill-in.ts

@@ -6,7 +6,7 @@ import settled from '../settled';
 import fireEvent from './fire-event';
 import Target, { isContentEditable } from './-target';
 import { log } from '@ember/test-helpers/dom/-logging';
-import { runHooks, registerHook } from '../-internal/helper-hooks';
+import { runHooks, registerHook } from '../helper-hooks';
 
 registerHook('fillIn', 'start', (target: Target, text: string) => {
   log('fillIn', target, text);

addon-test-support/@ember/test-helpers/dom/fire-event.ts

@@ -2,7 +2,7 @@ import { isDocument, isElement } from './-target';
 import tuple from '../-tuple';
 import Target from './-target';
 import { log } from '@ember/test-helpers/dom/-logging';
-import { runHooks, registerHook } from '../-internal/helper-hooks';
+import { runHooks, registerHook } from '../helper-hooks';
 
 registerHook('fireEvent', 'start', (target: Target) => {
   log('fireEvent', target);

addon-test-support/@ember/test-helpers/dom/focus.ts

@@ -4,7 +4,7 @@ import settled from '../settled';
 import isFocusable from './-is-focusable';
 import Target, { isDocument } from './-target';
 import { log } from '@ember/test-helpers/dom/-logging';
-import { runHooks, registerHook } from '../-internal/helper-hooks';
+import { runHooks, registerHook } from '../helper-hooks';
 import { __blur__ } from './blur';
 
 registerHook('focus', 'start', (target: Target) => {

addon-test-support/@ember/test-helpers/dom/scroll-to.ts

@@ -2,7 +2,7 @@ import getElement from './-get-element';
 import fireEvent from './fire-event';
 import settled from '../settled';
 import { isElement } from './-target';
-import { runHooks } from '../-internal/helper-hooks';
+import { runHooks } from '../helper-hooks';
 
 /**
   Scrolls DOM element or selector to the given coordinates.

addon-test-support/@ember/test-helpers/dom/select.ts

@@ -4,7 +4,7 @@ import { __focus__ } from './focus';
 import settled from '../settled';
 import fireEvent from './fire-event';
 import Target from './-target';
-import { runHooks } from '../-internal/helper-hooks';
+import { runHooks } from '../helper-hooks';
 
 /**
   Set the `selected` property true for the provided option the target is a

addon-test-support/@ember/test-helpers/dom/tab.ts

@@ -5,7 +5,7 @@ import Target, { isDocument } from './-target';
 import { __blur__ } from './blur';
 import { __focus__ } from './focus';
 import { isVisible, isDisabled } from '../-utils';
-import { registerHook, runHooks } from '../-internal/helper-hooks';
+import { registerHook, runHooks } from '../helper-hooks';
 import { log } from './-logging';
 
 const SUPPORTS_INERT = 'inert' in Element.prototype;

addon-test-support/@ember/test-helpers/dom/tap.ts

@@ -5,7 +5,7 @@ import settled from '../settled';
 import Target from './-target';
 import { log } from '@ember/test-helpers/dom/-logging';
 import isFormControl from './-is-form-control';
-import { runHooks, registerHook } from '../-internal/helper-hooks';
+import { runHooks, registerHook } from '../helper-hooks';
 
 registerHook('tap', 'start', (target: Target) => {
   log('tap', target);

addon-test-support/@ember/test-helpers/dom/trigger-event.ts

@@ -4,7 +4,7 @@ import settled from '../settled';
 import Target from './-target';
 import { log } from '@ember/test-helpers/dom/-logging';
 import isFormControl from './-is-form-control';
-import { runHooks, registerHook } from '../-internal/helper-hooks';
+import { runHooks, registerHook } from '../helper-hooks';
 
 registerHook('triggerEvent', 'start', (target: Target, eventType: string) => {
   log('triggerEvent', target, eventType);

addon-test-support/@ember/test-helpers/dom/trigger-key-event.ts

@@ -10,7 +10,7 @@ import { isNumeric } from '../-utils';
 import Target from './-target';
 import { log } from '@ember/test-helpers/dom/-logging';
 import isFormControl from './-is-form-control';
-import { runHooks, registerHook } from '../-internal/helper-hooks';
+import { runHooks, registerHook } from '../helper-hooks';
 
 registerHook(
   'triggerKeyEvent',

addon-test-support/@ember/test-helpers/dom/type-in.ts

@@ -11,7 +11,7 @@ import Target, {
 } from './-target';
 import { __triggerKeyEvent__ } from './trigger-key-event';
 import { log } from '@ember/test-helpers/dom/-logging';
-import { runHooks, registerHook } from '../-internal/helper-hooks';
+import { runHooks, registerHook } from '../helper-hooks';
 
 export interface Options {
   delay?: number;

addon-test-support/@ember/test-helpers/helper-hooks.ts

@@ -0,0 +1,95 @@
+export type Hook = (...args: any[]) => void | Promise<void>;
+export type HookLabel = 'start' | 'end' | 'targetFound';
+export type HookUnregister = {
+  unregister: () => void;
+};
+
+const registeredHooks = new Map<string, Set<Hook>>();
+
+/**
+ * @private
+ * @param {string} helperName The name of the test helper in which to run the hook.
+ * @param {string} label A label to help identify the hook.
+ * @returns {string} The compound key for the helper.
+ */
+function getHelperKey(helperName: string, label: string): string {
+  return `${helperName}:${label}`;
+}
+
+/**
+ * Registers a function to be run during the invocation of a test helper.
+ *
+ * @param {string} helperName The name of the test helper in which to run the hook.
+ *                            Test helper names include `blur`, `click`, `doubleClick`, `fillIn`,
+ *                            `fireEvent`, `focus`, `render`, `scrollTo`, `select`, `tab`, `tap`, `triggerEvent`,
+ *                            `triggerKeyEvent`, `typeIn`, and `visit`.
+ * @param {string} label A label to help identify the hook. Built-in labels include `start`, `end`,
+ *                       and `targetFound`, the former designating either the start or end of
+ *                       the helper invocation.
+ * @param {Function} hook The hook function to run when the test helper is invoked.
+ * @returns {HookUnregister} An object containing an `unregister` function that unregisters
+ *                           the specific hook initially registered to the helper.
+ * @example
+ * <caption>
+ *   Registering a hook for the `end` point of the `click` test helper invocation
+ * </caption>
+ *
+ * const hook = registerHook('click', 'end', () => {
+ *   console.log('Running `click:end` test helper hook');
+ * });
+ *
+ * // Unregister the hook at some later point in time
+ * hook.unregister();
+ */
+export function registerHook(
+  helperName: string,
+  label: HookLabel,
+  hook: Hook
+): HookUnregister {
+  let helperKey = getHelperKey(helperName, label);
+  let hooksForHelper = registeredHooks.get(helperKey);
+
+  if (hooksForHelper === undefined) {
+    hooksForHelper = new Set<Hook>();
+    registeredHooks.set(helperKey, hooksForHelper);
+  }
+
+  hooksForHelper.add(hook);
+
+  return {
+    unregister() {
+      hooksForHelper!.delete(hook);
+    },
+  };
+}
+
+/**
+ * Runs all hooks registered for a specific test helper.
+ *
+ * @param {string} helperName The name of the test helper in which to run the hook.
+ *                            Test helper names include `blur`, `click`, `doubleClick`, `fillIn`,
+ *                            `fireEvent`, `focus`, `render`, `scrollTo`, `select`, `tab`, `tap`, `triggerEvent`,
+ *                            `triggerKeyEvent`, `typeIn`, and `visit`.
+ * @param {string} label A label to help identify the hook. Built-in labels include `start`, `end`,
+ *                       and `targetFound`, the former designating either the start or end of
+ *                       the helper invocation.
+ * @param {unknown[]} args Any arguments originally passed to the test helper.
+ * @returns {Promise<void>} A promise representing the serial invocation of the hooks.
+ */
+export function runHooks(
+  helperName: string,
+  label: HookLabel,
+  ...args: unknown[]
+): Promise<void> {
+  let hooks =
+    registeredHooks.get(getHelperKey(helperName, label)) || new Set<Hook>();
+  let promises: Array<void | Promise<void>> = [];
+
+  hooks.forEach((hook) => {
+    let hookResult = hook(...args);
+
+    promises.push(hookResult);
+  });
+
+  return Promise.all(promises).then(() => {});
+}

addon-test-support/@ember/test-helpers/index.ts

@@ -50,9 +50,12 @@ export { default as registerDebugInfoHelper } from './-internal/debug-info-helpe
 export type { TestMetadata } from './test-metadata';
 export { default as getTestMetadata } from './test-metadata';
 export {
-  registerHook as _registerHook,
-  runHooks as _runHooks,
-} from './-internal/helper-hooks';
+  registerHook,
+  runHooks,
+  type Hook,
+  type HookLabel,
+  type HookUnregister,
+} from './helper-hooks';
 
 // DOM Helpers
 export { default as click } from './dom/click';

addon-test-support/@ember/test-helpers/setup-application-context.ts

@@ -9,7 +9,7 @@ import global from './global';
 import hasEmberVersion from './has-ember-version';
 import settled from './settled';
 import getTestMetadata from './test-metadata';
-import { runHooks } from './-internal/helper-hooks';
+import { runHooks } from './helper-hooks';
 import type Router from '@ember/routing/router';
 import type RouterService from '@ember/routing/router-service';
 import { assert } from '@ember/debug';

addon-test-support/@ember/test-helpers/setup-rendering-context.ts

@@ -14,7 +14,7 @@ import getRootElement from './dom/get-root-element';
 import { Owner } from './build-owner';
 import getTestMetadata from './test-metadata';
 import { assert } from '@ember/debug';
-import { runHooks } from './-internal/helper-hooks';
+import { runHooks } from './helper-hooks';
 import hasEmberVersion from './has-ember-version';
 import isComponent from './-internal/is-component';
 import { macroCondition, dependencySatisfies } from '@embroider/macros';

tests/helpers/register-hooks.js

@@ -1,4 +1,4 @@
-import { _registerHook } from '@ember/test-helpers';
+import { registerHook } from '@ember/test-helpers';
 
 /**
  * Register mock hooks for a helper and optional list of expected events performed while the helper is executed.
@@ -11,10 +11,10 @@ import { _registerHook } from '@ember/test-helpers';
  */
 export const registerHooks = (assert, helperName, { expectedEvents } = {}) => {
   const mockHooks = [
-    _registerHook(helperName, 'start', () => {
+    registerHook(helperName, 'start', () => {
       assert.step(`${helperName}:start`);
     }),
-    _registerHook(helperName, 'end', () => {
+    registerHook(helperName, 'end', () => {
       assert.step(`${helperName}:end`);
     }),
   ];
@@ -35,19 +35,19 @@ export const registerHooks = (assert, helperName, { expectedEvents } = {}) => {
  * @returns {HookUnregister[]} Unregisterable hooks
  */
 export const registerFireEventHooks = (assert, expectedEvents) => {
-  const startHook = _registerHook('fireEvent', 'start', () => {
+  const startHook = registerHook('fireEvent', 'start', () => {
     assert.step(`fireEvent:start`);
   });
-  const endHook = _registerHook('fireEvent', 'end', () => {
+  const endHook = registerHook('fireEvent', 'end', () => {
     assert.step(`fireEvent:end`);
   });
 
   const eventTypes = [...new Set(expectedEvents)];
   const eventSpecificHooks = eventTypes.flatMap((eventType) => [
-    _registerHook(`fireEvent:${eventType}`, 'start', () => {
+    registerHook(`fireEvent:${eventType}`, 'start', () => {
       assert.step(`fireEvent:${eventType}:start`);
     }),
-    _registerHook(`fireEvent:${eventType}`, 'end', () => {
+    registerHook(`fireEvent:${eventType}`, 'end', () => {
       assert.step(`fireEvent:${eventType}:end`);
     }),
   ]);

tests/unit/dom/blur-test.js

@@ -4,7 +4,7 @@ import {
   blur,
   setupContext,
   teardownContext,
-  _registerHook,
+  registerHook,
 } from '@ember/test-helpers';
 import { buildInstrumentedElement, insertElement } from '../../helpers/events';
 import { isEdge } from '../../helpers/browser-detect';
@@ -59,10 +59,10 @@ module('DOM Helper: blur', function (hooks) {
 
     await focus(element);
 
-    let startHook = _registerHook('blur', 'start', () => {
+    let startHook = registerHook('blur', 'start', () => {
       assert.step('blur:start');
     });
-    let endHook = _registerHook('blur', 'end', () => {
+    let endHook = registerHook('blur', 'end', () => {
       assert.step('blur:end');
     });