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/-internal/helper-hooks.ts → addon-test-support/@ember/test-helpers/helper-hooks.ts

@@ -1,6 +1,6 @@
-type Hook = (...args: any[]) => void | Promise<void>;
-type HookLabel = 'start' | 'end' | string;
-type HookUnregister = {
+export type Hook = (...args: any[]) => void | Promise<void>;
+export type HookLabel = 'start' | 'end' | string;
+export type HookUnregister = {
   unregister: () => void;
 };
 
@@ -62,7 +62,7 @@ export function registerHook(
 export function runHooks(
   helperName: string,
   label: HookLabel,
-  ...args: any[]
+  ...args: unknown[]
 ): Promise<void> {
   let hooks =
     registeredHooks.get(getHelperKey(helperName, label)) || new Set<Hook>();

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

@@ -49,10 +49,8 @@ export { getDebugInfo } from './-internal/debug-info';
 export { default as registerDebugInfoHelper } from './-internal/debug-info-helpers';
 export type { TestMetadata } from './test-metadata';
 export { default as getTestMetadata } from './test-metadata';
-export {
-  registerHook as _registerHook,
-  runHooks as _runHooks,
-} from './-internal/helper-hooks';
+export { registerHook, runHooks } from './helper-hooks';
+export type { Hook, HookLabel, 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');
     });
 

tests/unit/dom/focus-test.js

@@ -3,7 +3,7 @@ import {
   focus,
   setupContext,
   teardownContext,
-  _registerHook,
+  registerHook,
 } from '@ember/test-helpers';
 import {
   buildInstrumentedElement,
@@ -51,10 +51,10 @@ module('DOM Helper: focus', function (hooks) {
     element = document.createElement('input');
     insertElement(element);
 
-    let startHook = _registerHook('focus', 'start', () => {
+    let startHook = registerHook('focus', 'start', () => {
       assert.step('focus:start');
     });
-    let endHook = _registerHook('focus', 'end', () => {
+    let endHook = registerHook('focus', 'end', () => {
       assert.step('focus:end');
     });
 

tests/unit/dom/helper-hooks-test.js

@@ -1,17 +1,17 @@
 import { module, test } from 'qunit';
 import { Promise } from 'rsvp';
-import { _registerHook, _runHooks, isSettled } from '@ember/test-helpers';
+import { registerHook, runHooks, isSettled } from '@ember/test-helpers';
 
 module('helper hooks', function () {
   test('it can register a hook for a helper', async function (assert) {
     let func = () => assert.step('click:start hook');
-    let hook = _registerHook('click', 'start', func);
+    let hook = registerHook('click', 'start', func);
 
     try {
-      await _runHooks('click', 'start');
+      await runHooks('click', 'start');
       assert.verifySteps(['click:start hook']);
 
-      await _runHooks('click', 'start');
+      await runHooks('click', 'start');
       assert.verifySteps(['click:start hook']);
     } finally {
       hook.unregister();
@@ -20,17 +20,17 @@ module('helper hooks', function () {
 
   test('it can register an unregister a hook for a helper', async function (assert) {
     let func = () => assert.step('click:start hook');
-    let hook = _registerHook('click', 'start', func);
+    let hook = registerHook('click', 'start', func);
 
     try {
-      await _runHooks('click', 'start');
+      await runHooks('click', 'start');
       assert.verifySteps(['click:start hook']);
 
-      await _runHooks('click', 'start');
+      await runHooks('click', 'start');
       assert.verifySteps(['click:start hook']);
 
       hook.unregister();
-      await _runHooks('click', 'start');
+      await runHooks('click', 'start');
       assert.verifySteps([]);
     } finally {
       hook.unregister();
@@ -48,11 +48,11 @@ module('helper hooks', function () {
         }, 100);
       });
     };
-    let hook = _registerHook('click', 'start', func);
+    let hook = registerHook('click', 'start', func);
 
     try {
       assert.step('running hooks for click:start');
-      await _runHooks('click', 'start');
+      await runHooks('click', 'start');
       assert.step('hooks finished for click:start');
 
       assert.verifySteps([
@@ -67,15 +67,15 @@ module('helper hooks', function () {
   });
 
   test('it can run hooks for a helper by label', async function (assert) {
-    let fooHook1 = _registerHook('click', 'foo', () => {
+    let fooHook1 = registerHook('click', 'foo', () => {
       assert.step('click:foo1');
     });
-    let fooHook2 = _registerHook('click', 'foo', () => {
+    let fooHook2 = registerHook('click', 'foo', () => {
       assert.step('click:foo2');
     });
 
     try {
-      await _runHooks('click', 'foo');
+      await runHooks('click', 'foo');
 
       assert.verifySteps(['click:foo1', 'click:foo2']);
     } finally {
@@ -85,15 +85,15 @@ module('helper hooks', function () {
   });
 
   test('it is settled after runHooks resolves', async function (assert) {
-    await _runHooks('missing-thing', 'start');
+    await runHooks('missing-thing', 'start');
 
     assert.ok(isSettled(), 'is settled after runHooks with no hooks');
 
     let func = () => {};
-    let hook = _registerHook('present-thing', 'start', func);
+    let hook = registerHook('present-thing', 'start', func);
 
     try {
-      await _runHooks('click', 'start');
+      await runHooks('click', 'start');
 
       assert.ok(isSettled(), 'is settled after runHooks when a hook exists');
     } finally {

tests/unit/dom/trigger-event-test.js

@@ -3,7 +3,7 @@ import {
   triggerEvent,
   setupContext,
   teardownContext,
-  _registerHook,
+  registerHook,
 } from '@ember/test-helpers';
 import { buildInstrumentedElement, insertElement } from '../../helpers/events';
 import hasEmberVersion from '@ember/test-helpers/has-ember-version';
@@ -44,10 +44,10 @@ module('DOM Helper: triggerEvent', function (hooks) {
     element = document.createElement('div');
     insertElement(element);
 
-    let startHook = _registerHook('triggerEvent', 'start', () => {
+    let startHook = registerHook('triggerEvent', 'start', () => {
       assert.step('triggerEvent:start');
     });
-    let endHook = _registerHook('triggerEvent', 'end', () => {
+    let endHook = registerHook('triggerEvent', 'end', () => {
       assert.step('triggerEvent:end');
     });
 

tests/unit/dom/trigger-key-event-test.js

@@ -3,7 +3,7 @@ import {
   triggerKeyEvent,
   setupContext,
   teardownContext,
-  _registerHook,
+  registerHook,
 } from '@ember/test-helpers';
 import { buildInstrumentedElement, insertElement } from '../../helpers/events';
 import hasEmberVersion from '@ember/test-helpers/has-ember-version';
@@ -44,10 +44,10 @@ module('DOM Helper: triggerKeyEvent', function (hooks) {
     element = document.createElement('div');
     insertElement(element);
 
-    let startHook = _registerHook('triggerKeyEvent', 'start', () => {
+    let startHook = registerHook('triggerKeyEvent', 'start', () => {
       assert.step('triggerKeyEvent:start');
     });
-    let endHook = _registerHook('triggerKeyEvent', 'end', () => {
+    let endHook = registerHook('triggerKeyEvent', 'end', () => {
       assert.step('triggerKeyEvent:end');
     });