@discourse/types 0.0.2 → 2026.1.0-2709d36

package/external-types/@ember__test-helpers/declarations/setup-application-context.d.ts

@@ -1,69 +0,0 @@
-declare module '@ember/test-helpers/setup-application-context' {
-import { type BaseContext, type TestContext } from './setup-context.ts';
-export interface ApplicationTestContext extends TestContext {
-    element?: Element | null;
-}
-export declare function isApplicationTestContext(context: BaseContext): context is ApplicationTestContext;
-/**
-  Determines if we have any pending router transitions (used to determine `settled` state)
-
-  @public
-  @returns {(boolean|null)} if there are pending transitions
-*/
-export declare function hasPendingTransitions(): boolean | null;
-/**
-  Setup the current router instance with settledness tracking. Generally speaking this
-  is done automatically (during a `visit('/some-url')` invocation), but under some
-  circumstances (e.g. a non-application test where you manually call `this.owner.setupRouter()`)
-  you may want to call it yourself.
-
-  @public
- */
-export declare function setupRouterSettlednessTracking(): void;
-/**
-  Navigate the application to the provided URL.
-
-  @public
-  @param {string} url The URL to visit (e.g. `/posts`)
-  @param {object} options app boot options
-  @returns {Promise<void>} resolves when settled
-
-  @example
-  <caption>
-    Visiting the route for post 1.
-  </caption>
-  await visit('/posts/1');
-
-  @example
-  <caption>
-    Visiting the route for post 1 while also providing the `rootElement` app boot option.
-  </caption>
-  await visit('/', { rootElement: '#container' });
-*/
-export declare function visit(url: string, options?: Record<string, unknown>): Promise<void>;
-/**
-  @public
-  @returns {string} the currently active route name
-*/
-export declare function currentRouteName(): string;
-/**
-  @public
-  @returns {string} the applications current url
-*/
-export declare function currentURL(): string;
-/**
-  Used by test framework addons to setup the provided context for working with
-  an application (e.g. routing).
-
-  `setupContext` must have been run on the provided context prior to calling
-  `setupApplicationContext`.
-
-  Sets up the basic framework used by application tests.
-
-  @public
-  @param {Object} context the context to setup
-  @returns {Promise<void>} resolves when the context is set up
-*/
-export default function setupApplicationContext(context: TestContext): Promise<void>;
-//# sourceMappingURL=setup-application-context.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/setup-context.d.ts

@@ -1,209 +0,0 @@
-declare module '@ember/test-helpers/setup-context' {
-import type { Resolver } from '@ember/owner';
-import { type Owner } from './build-owner.ts';
-import { type DeprecationFailure } from './-internal/deprecations.ts';
-import { type Warning } from './-internal/warnings.ts';
-export interface SetupContextOptions {
-    resolver?: Resolver | undefined;
-}
-export type BaseContext = object;
-/**
- * The public API for the test context, which test authors can depend on being
- * available.
- *
- * Note: this is *not* user-constructible; it becomes available by calling
- * `setupContext()` with a base context object.
- */
-export interface TestContext extends BaseContext {
-    owner: Owner;
-    set<T>(key: string, value: T): T;
-    setProperties<T extends Record<string, unknown>>(hash: T): T;
-    get(key: string): unknown;
-    getProperties(...args: string[]): Record<string, unknown>;
-    pauseTest(): Promise<void>;
-    resumeTest(): void;
-}
-export declare function isTestContext(context: BaseContext): context is TestContext;
-/**
-  Stores the provided context as the "global testing context".
-
-  Generally setup automatically by `setupContext`.
-
-  @public
-  @param {Object} context the context to use
-*/
-export declare function setContext(context: BaseContext): void;
-/**
-  Retrieve the "global testing context" as stored by `setContext`.
-
-  @public
-  @returns {Object} the previously stored testing context
-*/
-export declare function getContext(): BaseContext | undefined;
-/**
-  Clear the "global testing context".
-
-  Generally invoked from `teardownContext`.
-
-  @public
-*/
-export declare function unsetContext(): void;
-/**
- * Returns a promise to be used to pauses the current test (due to being
- * returned from the test itself).  This is useful for debugging while testing
- * or for test-driving.  It allows you to inspect the state of your application
- * at any point.
- *
- * The test framework wrapper (e.g. `ember-qunit` or `ember-mocha`) should
- * ensure that when `pauseTest()` is used, any framework specific test timeouts
- * are disabled.
- *
- * @public
- * @returns {Promise<void>} resolves _only_ when `resumeTest()` is invoked
- * @example <caption>Usage via ember-qunit</caption>
- *
- * import { setupRenderingTest } from 'ember-qunit';
- * import { render, click, pauseTest } from '@ember/test-helpers';
- *
- *
- * module('awesome-sauce', function(hooks) {
- *   setupRenderingTest(hooks);
- *
- *   test('does something awesome', async function(assert) {
- *     await render(hbs`{{awesome-sauce}}`);
- *
- *     // added here to visualize / interact with the DOM prior
- *     // to the interaction below
- *     await pauseTest();
- *
- *     click('.some-selector');
- *
- *     assert.equal(this.element.textContent, 'this sauce is awesome!');
- *   });
- * });
- */
-export declare function pauseTest(): Promise<void>;
-/**
-  Resumes a test previously paused by `await pauseTest()`.
-
-  @public
-*/
-export declare function resumeTest(): void;
-/**
- * Returns deprecations which have occurred so far for a the current test context
- *
- * @public
- * @returns {Array<DeprecationFailure>} An array of deprecation messages
- * @example <caption>Usage via ember-qunit</caption>
- *
- * import { getDeprecations } from '@ember/test-helpers';
- *
- * module('awesome-sauce', function(hooks) {
- *   setupRenderingTest(hooks);
- *
- *   test('does something awesome', function(assert) {
-       const deprecations = getDeprecations() // => returns deprecations which have occurred so far in this test
- *   });
- * });
- */
-export declare function getDeprecations(): Array<DeprecationFailure>;
-export type { DeprecationFailure };
-/**
- * Returns deprecations which have occurred so far for a the current test context
- *
- * @public
- * @param {Function} [callback] The callback that when executed will have its DeprecationFailure recorded
- * @returns {Array<DeprecationFailure> | Promise<Array<DeprecationFailure>>} An array of deprecation messages
- * @example <caption>Usage via ember-qunit</caption>
- *
- * import { getDeprecationsDuringCallback } from '@ember/test-helpers';
- *
- * module('awesome-sauce', function(hooks) {
- *   setupRenderingTest(hooks);
- *
- *   test('does something awesome', function(assert) {
- *     const deprecations = getDeprecationsDuringCallback(() => {
- *       // code that might emit some deprecations
- *
- *     }); // => returns deprecations which occurred while the callback was invoked
- *   });
- *
- *
- *   test('does something awesome', async function(assert) {
- *     const deprecations = await getDeprecationsDuringCallback(async () => {
- *       // awaited code that might emit some deprecations
- *     }); // => returns deprecations which occurred while the callback was invoked
- *   });
- * });
- */
-export declare function getDeprecationsDuringCallback(callback: () => void): Array<DeprecationFailure> | Promise<Array<DeprecationFailure>>;
-/**
- * Returns warnings which have occurred so far for a the current test context
- *
- * @public
- * @returns {Array<Warning>} An array of warnings
- * @example <caption>Usage via ember-qunit</caption>
- *
- * import { getWarnings } from '@ember/test-helpers';
- *
- * module('awesome-sauce', function(hooks) {
- *   setupRenderingTest(hooks);
- *
- *   test('does something awesome', function(assert) {
-       const warnings = getWarnings() // => returns warnings which have occurred so far in this test
- *   });
- * });
- */
-export declare function getWarnings(): Array<Warning>;
-export type { Warning };
-/**
- * Returns warnings which have occurred so far for a the current test context
- *
- * @public
- * @param {Function} [callback] The callback that when executed will have its warnings recorded
- * @returns {Array<Warning> | Promise<Array<Warning>>} An array of warnings information
- * @example <caption>Usage via ember-qunit</caption>
- *
- * import { getWarningsDuringCallback } from '@ember/test-helpers';
- * import { warn } from '@ember/debug';
- *
- * module('awesome-sauce', function(hooks) {
- *   setupRenderingTest(hooks);
- *
- *   test('does something awesome', function(assert) {
- *     const warnings = getWarningsDuringCallback(() => {
- *     warn('some warning');
- *
- *     }); // => returns warnings which occurred while the callback was invoked
- *   });
- *
- *   test('does something awesome', async function(assert) {
- *     warn('some warning');
- *
- *     const warnings = await getWarningsDuringCallback(async () => {
- *       warn('some other warning');
- *     }); // => returns warnings which occurred while the callback was invoked
- *   });
- * });
- */
-export declare function getWarningsDuringCallback(callback: () => void): Array<Warning> | Promise<Array<Warning>>;
-/**
-  Used by test framework addons to setup the provided context for testing.
-
-  Responsible for:
-
-  - sets the "global testing context" to the provided context (`setContext`)
-  - create an owner object and set it on the provided context (e.g. `this.owner`)
-  - setup `this.set`, `this.setProperties`, `this.get`, and `this.getProperties` to the provided context
-  - setting up AJAX listeners
-  - setting up `pauseTest` (also available as `this.pauseTest()`) and `resumeTest` helpers
-
-  @public
-  @param {Object} base the context to setup
-  @param {Object} [options] options used to override defaults
-  @param {Resolver} [options.resolver] a resolver to use for customizing normal resolution
-  @returns {Promise<Object>} resolves with the context that was setup
-*/
-export default function setupContext<T extends object>(base: T, options?: SetupContextOptions): Promise<T & TestContext>;
-//# sourceMappingURL=setup-context.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/setup-onerror.d.ts

@@ -1,53 +0,0 @@
-declare module '@ember/test-helpers/setup-onerror' {
-import { type BaseContext } from './setup-context.ts';
-/**
- * Sets the `Ember.onerror` function for tests. This value is intended to be reset after
- * each test to ensure correct test isolation. To reset, you should simply call `setupOnerror`
- * without an `onError` argument.
- *
- * @public
- * @param {Function} onError the onError function to be set on Ember.onerror
- *
- * @example <caption>Example implementation for `ember-qunit` or `ember-mocha`</caption>
- *
- * import { setupOnerror } from '@ember/test-helpers';
- *
- * test('Ember.onerror is stubbed properly', function(assert) {
- *   setupOnerror(function(err) {
- *     assert.ok(err);
- *   });
- * });
- */
-export default function setupOnerror(onError?: (error: Error) => void): void;
-/**
- * Resets `Ember.onerror` to the value it originally was at the start of the test run.
- * If there is no context or cached value this is a no-op.
- *
- * @public
- *
- * @example
- *
- * import { resetOnerror } from '@ember/test-helpers';
- *
- * QUnit.testDone(function() {
- *   resetOnerror();
- * })
- */
-export declare function resetOnerror(): void;
-/**
- * Caches the current value of Ember.onerror. When `setupOnerror` is called without a value
- * or when `resetOnerror` is called the value will be set to what was cached here.
- *
- * @private
- * @param {BaseContext} context the text context
- */
-export declare function _prepareOnerror(context: BaseContext): void;
-/**
- * Removes the cached value of Ember.onerror.
- *
- * @private
- * @param {BaseContext} context the text context
- */
-export declare function _cleanupOnerror(context: BaseContext): void;
-//# sourceMappingURL=setup-onerror.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/setup-rendering-context.d.ts

@@ -1,75 +0,0 @@
-declare module '@ember/test-helpers/setup-rendering-context' {
-import { type BaseContext, type TestContext } from './setup-context.ts';
-import type { Owner } from './build-owner.ts';
-declare const hasCalledSetupRenderingContext: unique symbol;
-export interface RenderingTestContext extends TestContext {
-    element: Element | Document;
-    [hasCalledSetupRenderingContext]?: true;
-}
-export declare function isRenderingTestContext(context: BaseContext): context is RenderingTestContext;
-export interface RenderOptions {
-    /**
-      The owner object to use as the basis for the template. In most cases you
-      will not need to specify this, however if you are using ember-engines
-      it is possible to specify the _engine's_ owner instead of the host
-      applications.
-    */
-    owner?: Owner;
-}
-/**
-  Renders the provided template and appends it to the DOM.
-
-  @public
-  @param {Template|Component} templateFactoryOrComponent the component (or template) to render
-  @param {RenderOptions} options options hash containing engine owner ({ owner: engineOwner })
-  @returns {Promise<void>} resolves when settled
-
-  @example
-  <caption>
-    Render a div element with the class 'container'.
-  </caption>
-  await render(hbs`<div class="container"></div>`);
-*/
-export declare function render(templateFactoryOrComponent: object, options?: RenderOptions): Promise<void>;
-/**
-  Clears any templates previously rendered. This is commonly used for
-  confirming behavior that is triggered by teardown (e.g.
-  `willDestroyElement`).
-
-  @public
-  @returns {Promise<void>} resolves when settled
-*/
-export declare function clearRender(): Promise<void>;
-/**
-  Used by test framework addons to setup the provided context for rendering.
-
-  `setupContext` must have been ran on the provided context
-  prior to calling `setupRenderingContext`.
-
-  Responsible for:
-
-  - Setup the basic framework used for rendering by the
-    `render` helper.
-  - Ensuring the event dispatcher is properly setup.
-  - Setting `this.element` to the root element of the testing
-    container (things rendered via `render` will go _into_ this
-    element).
-
-  @public
-  @param {TestContext} context the context to setup for rendering
-  @returns {Promise<RenderingTestContext>} resolves with the context that was setup
-
-  @example
-  <caption>
-    Rendering out a paragraph element containing the content 'hello', and then clearing that content via clearRender.
-  </caption>
-
-  await render(hbs`<p>Hello!</p>`);
-  assert.equal(this.element.textContent, 'Hello!', 'has rendered content');
-  await clearRender();
-  assert.equal(this.element.textContent, '', 'has rendered content');
-*/
-export default function setupRenderingContext(context: TestContext): Promise<RenderingTestContext>;
-export {};
-//# sourceMappingURL=setup-rendering-context.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/teardown-context.d.ts

@@ -1,23 +0,0 @@
-declare module '@ember/test-helpers/teardown-context' {
-import type { TestContext } from './setup-context';
-export interface TeardownContextOptions {
-    waitForSettled?: boolean | undefined;
-}
-/**
-  Used by test framework addons to tear down the provided context after testing is completed.
-
-  Responsible for:
-
-  - un-setting the "global testing context" (`unsetContext`)
-  - destroy the contexts owner object
-  - remove AJAX listeners
-
-  @public
-  @param {Object} context the context to setup
-  @param {Object} [options] options used to override defaults
-  @param {boolean} [options.waitForSettled=true] should the teardown wait for `settled()`ness
-  @returns {Promise<void>} resolves when settled
-*/
-export default function teardownContext(context: TestContext, { waitForSettled }?: TeardownContextOptions): Promise<void>;
-//# sourceMappingURL=teardown-context.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/test-metadata.d.ts

@@ -1,28 +0,0 @@
-declare module '@ember/test-helpers/test-metadata' {
-import type { BaseContext } from './setup-context';
-declare class TestMetadata {
-    [key: string]: any;
-    testName?: string;
-    setupTypes: string[];
-    usedHelpers: string[];
-    constructor();
-    get isRendering(): boolean;
-    get isApplication(): boolean;
-}
-export { TestMetadata as __TestMetadata, };
-export type { 
-/**
- * A non-user-constructible interface representing the metadata associated
- * with a test, designed for test frameworks to use e.g. with their reporters.
- */
-TestMetadata, };
-/**
- * Gets the test metadata associated with the provided test context. Will create
- * a new test metadata object if one does not exist.
- *
- * @param {BaseContext} context the context to use
- * @returns {TestMetadata} the test metadata for the provided context
- */
-export default function getTestMetadata(context: BaseContext): TestMetadata;
-//# sourceMappingURL=test-metadata.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/validate-error-handler.d.ts

@@ -1,35 +0,0 @@
-declare module '@ember/test-helpers/validate-error-handler' {
-type ErrorHandlerValidation = Readonly<{
-    isValid: true;
-    message: null;
-}> | Readonly<{
-    isValid: false;
-    message: string;
-}>;
-/**
- * Validate the provided error handler to confirm that it properly re-throws
- * errors when `Ember.testing` is true.
- *
- * This is intended to be used by test framework hosts (or other libraries) to
- * ensure that `Ember.onerror` is properly configured. Without a check like
- * this, `Ember.onerror` could _easily_ swallow all errors and make it _seem_
- * like everything is just fine (and have green tests) when in reality
- * everything is on fire...
- *
- * @public
- * @param {Function} [callback=Ember.onerror] the callback to validate
- * @returns {Object} object with `isValid` and `message`
- *
- * @example <caption>Example implementation for `ember-qunit`</caption>
- *
- * import { validateErrorHandler } from '@ember/test-helpers';
- *
- * test('Ember.onerror is functioning properly', function(assert) {
- *   let result = validateErrorHandler();
- *   assert.ok(result.isValid, result.message);
- * });
- */
-export default function validateErrorHandler(callback?: Function | undefined): ErrorHandlerValidation;
-export {};
-//# sourceMappingURL=validate-error-handler.d.ts.map
-}

package/external-types/@ember__test-helpers/declarations/wait-until.d.ts

@@ -1,31 +0,0 @@
-declare module '@ember/test-helpers/wait-until' {
-type Falsy = false | 0 | '' | null | undefined;
-export interface Options {
-    timeout?: number;
-    timeoutMessage?: string;
-}
-/**
-  Wait for the provided callback to return a truthy value.
-
-  This does not leverage `settled()`, and as such can be used to manage async
-  while _not_ settled (e.g. "loading" or "pending" states).
-
-  @public
-  @param {Function} callback the callback to use for testing when waiting should stop
-  @param {Object} [options] options used to override defaults
-  @param {number} [options.timeout=1000] the maximum amount of time to wait
-  @param {string} [options.timeoutMessage='waitUntil timed out'] the message to use in the reject on timeout
-  @returns {Promise} resolves with the callback value when it returns a truthy value
-
-  @example
-  <caption>
-    Waiting until a selected element displays text:
-  </caption>
-  await waitUntil(function() {
-    return find('.my-selector').textContent.includes('something')
-  }, { timeout: 2000 })
-*/
-export default function waitUntil<T>(callback: () => T | void | Falsy, options?: Options): Promise<T>;
-export {};
-//# sourceMappingURL=wait-until.d.ts.map
-}