@discourse/types 0.0.2 → 2026.1.0-2709d36

package/external-types/ember-modifier/declarations/-private/class-based/modifier.d.ts

@@ -1,66 +0,0 @@
-declare module 'ember-modifier/-private/class-based/modifier' {
-import type Owner from '@ember/owner';
-import type { ElementFor, ArgsFor, DefaultSignature, PositionalArgs, NamedArgs } from '../signature';
-import type Opaque from '../opaque';
-export default interface ClassBasedModifier<S = DefaultSignature> extends Opaque<S> {
-}
-/**
- * A base class for modifiers which need more capabilities than function-based
- * modifiers. Useful if, for example:
- *
- * 1. You need to inject services and access them
- * 2. You need fine-grained control of updates, either for performance or
- *    convenience reasons, and don't want to teardown the state of your modifier
- *    every time only to set it up again.
- * 3. You need to store some local state within your modifier.
- *
- * The lifecycle hooks of class modifiers are tracked. When they run, they any
- * values they access will be added to the modifier, and the modifier will
- * update if any of those values change.
- */
-export default class ClassBasedModifier<S = DefaultSignature> {
-    /**
-     *
-     * @param owner An instance of an Owner (for service injection etc.).
-     * @param args The positional and named arguments passed to the modifier.
-     */
-    constructor(owner: Owner, args: ArgsFor<S>);
-    /**
-     * Called when the modifier is installed and any time any tracked state used
-     * in the modifier changes.
-     *
-     * If you need to do first-time-only setup, create a class field representing
-     * the initialization state and check it when running the hook. That is also
-     * where and when you should use `registerDestructor` for any teardown you
-     * need to do. For example:
-     *
-     * ```js
-     * function disconnect(instance) {
-     *  instance.observer?.disconnect();
-     * }
-     *
-     * class IntersectionObserver extends Modifier {
-     *   observer;
-     *
-     *   constructor(owner, args) {
-     *     super(owner, args);
-     *     registerDestructor(this, disconnect);
-     *   }
-     *
-     *   modify(element, callback, options) {
-     *     disconnect(this);
-     *
-     *     this.observer = new IntersectionObserver(callback, options);
-     *     this.observer.observe(element);
-     *   }
-     * }
-     * ```
-     *
-     * @param element The element to which the modifier is applied.
-     * @param positional The positional arguments to the modifier.
-     * @param named The named arguments to the modifier.
-     */
-    modify(element: ElementFor<S>, positional: PositionalArgs<S>, named: NamedArgs<S>): void;
-}
-//# sourceMappingURL=modifier.d.ts.map
-}

package/external-types/ember-modifier/declarations/-private/function-based/modifier-manager.d.ts

@@ -1,25 +0,0 @@
-declare module 'ember-modifier/-private/function-based/modifier-manager' {
-import type { FunctionBasedModifierDefinition, Teardown } from './modifier';
-import type { ArgsFor, ElementFor } from '../signature';
-interface State<S> {
-    instance: FunctionBasedModifierDefinition<S>;
-}
-interface CreatedState<S> extends State<S> {
-    element: null;
-}
-interface InstalledState<S> extends State<S> {
-    element: ElementFor<S>;
-    teardown?: Teardown;
-}
-export default class FunctionBasedModifierManager<S> {
-    capabilities: unknown;
-    createModifier(instance: FunctionBasedModifierDefinition<S>): CreatedState<S>;
-    installModifier(createdState: CreatedState<S>, element: ElementFor<S>, args: ArgsFor<S>): void;
-    updateModifier(state: InstalledState<S>, args: ArgsFor<S>): void;
-    destroyModifier(state: InstalledState<S>): void;
-    getDebugName(state: InstalledState<S>): string;
-    getDebugInstance(state: InstalledState<S>): InstalledState<S>;
-}
-export {};
-//# sourceMappingURL=modifier-manager.d.ts.map
-}

package/external-types/ember-modifier/declarations/-private/function-based/modifier.d.ts

@@ -1,71 +0,0 @@
-declare module 'ember-modifier/-private/function-based/modifier' {
-import type { ElementFor, EmptyObject, NamedArgs, PositionalArgs } from '../signature';
-import type Modifier from '../class-based/modifier';
-export declare abstract class FunctionBasedModifierInstance<S> extends Modifier<S> {
-    protected abstract __concrete__: never;
-}
-export type FunctionBasedModifier<S> = abstract new () => FunctionBasedModifierInstance<S>;
-/**
- * The (optional) return type for a modifier which needs to perform some kind of
- * cleanup or teardown -- for example, removing an event listener from an
- * element besides the one passed into the modifier.
- */
-export type Teardown = () => unknown;
-/**
- * An API for writing simple modifiers.
- *
- * This function runs the first time when the element the modifier was applied
- * to is inserted into the DOM, and it *autotracks* while running. Any values
- * that it accesses will be tracked, including any of its arguments that it
- * accesses, and if any of them changes, the function will run again.
- *
- * **Note:** this will *not* automatically rerun because an argument changes. It
- * will only rerun if it is *using* that argument (the same as with auto-tracked
- * state in general).
- *
- * The modifier can also optionally return a *destructor*. The destructor
- * function will be run just before the next update, and when the element is
- * being removed entirely. It should generally clean up the changes that the
- * modifier made in the first place.
- *
- * @param fn The function which defines the modifier.
- */
-export default function modifier<E extends Element, P extends unknown[], N = EmptyObject>(fn: (element: E, positional: P, named: N) => void | Teardown): FunctionBasedModifier<{
-    Args: {
-        Positional: P;
-        Named: N;
-    };
-    Element: E;
-}>;
-/**
- * An API for writing simple modifiers.
- *
- * This function runs the first time when the element the modifier was applied
- * to is inserted into the DOM, and it *autotracks* while running. Any values
- * that it accesses will be tracked, including any of its arguments that it
- * accesses, and if any of them changes, the function will run again.
- *
- * **Note:** this will *not* automatically rerun because an argument changes. It
- * will only rerun if it is *using* that argument (the same as with auto-tracked
- * state in general).
- *
- * The modifier can also optionally return a *destructor*. The destructor
- * function will be run just before the next update, and when the element is
- * being removed entirely. It should generally clean up the changes that the
- * modifier made in the first place.
- *
- * @param fn The function which defines the modifier.
- */
-export default function modifier<S>(fn: (element: ElementFor<S>, positional: PositionalArgs<S>, named: NamedArgs<S>) => void | Teardown): FunctionBasedModifier<{
-    Element: ElementFor<S>;
-    Args: {
-        Named: NamedArgs<S>;
-        Positional: PositionalArgs<S>;
-    };
-}>;
-/**
- * @internal
- */
-export type FunctionBasedModifierDefinition<S> = (element: ElementFor<S>, positional: PositionalArgs<S>, named: NamedArgs<S>) => void | Teardown;
-//# sourceMappingURL=modifier.d.ts.map
-}

package/external-types/ember-modifier/declarations/-private/opaque.d.ts

@@ -1,10 +0,0 @@
-declare module 'ember-modifier/-private/opaque' {
-declare const Brand: unique symbol;
-declare class _Opaque<T> {
-    private readonly [Brand];
-}
-interface Opaque<T> extends _Opaque<T> {
-}
-export default Opaque;
-//# sourceMappingURL=opaque.d.ts.map
-}

package/external-types/ember-modifier/declarations/-private/signature.d.ts

@@ -1,107 +0,0 @@
-declare module 'ember-modifier/-private/signature' {
-/** @private */
-export type ElementFor<S> = 'Element' extends keyof S ? S['Element'] extends Element ? S['Element'] : Element : Element;
-type DefaultPositional = [];
-type GetOrElse<T, K, Fallback> = K extends keyof T ? T[K] : Fallback;
-/**
- * A convenience type utility, primarily for working with args in the `modify`
- * hook on class-based modifiers. Given a signature `S` it will return the
- * correct positional args for that signature. For example:
- *
- * ```ts
- * import Modifier, { NamedArgs } from 'ember-modifier';
- *
- * interface OnClickOutsideSig {
- *   Args: {
- *     Positional: [handler: () => void];
- *   };
- * }
- *
- * export default class Example extends Modifier<OnClickOutsideSig> {
- *   element = null;
- *
- *   modify(el: Element, _: [handler]: PositionalArgs<OnClickOutsideSig>) {
- *     if (!this.element) {
- *       this.element = el;
- *     }
- *
- *     this.clearHandler();
- *     this.handler = handler;
- *
- *     document.addEventListener('click', this.onClickOutside);
- *
- *     // Normally this would be better done in `constructor` or similar.
- *     unregisterDestructor(this, this.clearHandler);
- *     registerDestructor(this, this.clearHandler);
- *   }
- *
- *   onClickOutside = (event: MouseEvent) => {
- *     // SAFETY: a "standard" safe cast for event.target here
- *     if (!this.element.contains(event.target as Node)) {
- *       this.handler();
- *     }
- *   }
- *
- *   clearHandler = () => {
- *     document.removeEventListener('click', this.onClickOutside);
- *   }
- * }
- * ```
- *
- * (This example does not need to be, and should not be, class-based, but is
- * useful to illustrate how to use the type utility.)
- */
-export type PositionalArgs<S> = 'Args' extends keyof S ? GetOrElse<S['Args'], 'Positional', DefaultPositional> : DefaultPositional;
-declare const Empty: unique symbol;
-export interface EmptyObject {
-    [Empty]?: true;
-}
-type DefaultNamed = EmptyObject;
-/**
- * A convenience type utility, primarily for working with args in the `modify`
- * hook on class-based modifiers. Given a signature `S` it will return the
- * correct named args for that signature:
- *
- * ```ts
- * import Modifier, { NamedArgs } from 'ember-modifier';
- *
- * interface PlaySig {
- *   Element: HTMLElement;
- *   Args: {
- *     Named: {
- *       when: string;
- *     };
- *   };
- * }
- *
- * export default class Example extends Modifier<Sig> {
- *   modify(el: HTMLMediaElement, _: [], { when: shouldPlay }: NamedArgs<PlaySig>) {
- *     if (shouldPlay) {
- *       el.play();
- *     } else {
- *       el.pause();
- *     }
- *   }
- * }
- * ```
- *
- * (This example does not need to be, and should not be, class-based, but is
- * useful to illustrate the point.)
- */
-export type NamedArgs<S> = 'Args' extends keyof S ? GetOrElse<S['Args'], 'Named', DefaultNamed> : DefaultNamed;
-/** @private */
-export interface DefaultSignature {
-    Element: Element;
-}
-/**
- * A convenience type utility, primarily for working with args in the `modify`
- * hook on class-based modifiers. Given a signature `S` it will return the
- * correct positional args for that signature, to be used with
- */
-export interface ArgsFor<S> {
-    named: NamedArgs<S>;
-    positional: PositionalArgs<S>;
-}
-export {};
-//# sourceMappingURL=signature.d.ts.map
-}

package/external-types/ember-modifier/declarations/index.d.ts

@@ -1,7 +0,0 @@
-declare module 'ember-modifier' {
-export { default } from './-private/class-based/modifier.ts';
-export { default as modifier } from './-private/function-based/modifier.ts';
-export type { FunctionBasedModifier } from './-private/function-based/modifier.ts';
-export type { ArgsFor, NamedArgs, PositionalArgs, } from './-private/signature.ts';
-//# sourceMappingURL=index.d.ts.map
-}

package/external-types/ember-qunit/types/index.d.ts

@@ -1,285 +0,0 @@
-declare module 'ember-qunit' {
-// Type definitions for ember-qunit 5.0
-// Project: https://github.com/emberjs/ember-qunit#readme
-// Definitions by: Dan Freeman <https://github.com/dfreeman>
-//                 Chris Krycho <https://github.com/chriskrycho>
-//                 James C. Davis <https://github.com/jamescdavis>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// Minimum TypeScript Version: 4.4
-
-import EmberTestAdapter from '@ember/test/adapter';
-import { Resolver } from '@ember/owner';
-import { TestContext } from '@ember/test-helpers';
-
-/**
- * Sets a Resolver globally which will be used to look up objects from each test's container.
- */
-export function setResolver(resolver: Resolver): void;
-
-/**
- * Options for configuring the test runner. Normally, you will not need to
- * customize this. It is exported primarily so that end user app code can name
- * it when passing it back to the framework.
- */
-export interface SetupTestOptions {
-  /**
-   * The resolver to use when instantiating container-managed entities in the test.
-   */
-  resolver?: Resolver | undefined;
-}
-
-/**
- * Sets up acceptance tests.
- *
- * The `setupApplicationTest` function is used for all acceptance tests. It
- * is invoked in the callback scope of a QUnit module (aka "nested module").
- *
- * Once invoked, all subsequent hooks.beforeEach and test invocations will
- * have access to the following:
- * * `this.owner` - the owner object that been set on the test context.
- * * `this.pauseTest` and `this.resumeTest` - allow easy pausing/resuming of tests.
- * * `this.element` which returns the DOM element representing the application's root element.
- */
-export function setupApplicationTest(
-  hooks: NestedHooks,
-  options?: SetupTestOptions
-): void;
-
-/**
- * Sets up tests that need to render snippets of templates.
- *
- * The setupRenderingTest method is used for tests that need to render
- * snippets of templates. It is also invoked in the callback scope of a
- * QUnit module (aka "nested module").
- *
- * Once invoked, all subsequent hooks.beforeEach and test invocations will
- * have access to the following:
- * * All of the methods / properties listed for `setupTest`
- * * this.render(...) - Renders the provided template snippet returning a
- * promise that resolves once rendering has completed
- * * An importable render function that de-sugars into this.render will be
- * the default output of blueprints
- * * this.element - Returns the native DOM element representing the element
- * that was rendered via this.render
- * * this.$(...) - When jQuery is present, executes a jQuery selector with
- * the current this.element as its root
- */
-export function setupRenderingTest(
-  hooks: NestedHooks,
-  options?: SetupTestOptions
-): void;
-
-/**
- * Sets up tests that do not need to render snippets of templates.
- *
- * The `setupTest` method is used for all types of tests except for those
- * that need to render snippets of templates. It is invoked in the callback
- * scope of a QUnit module (aka "nested module").
- *
- * Once invoked, all subsequent hooks.beforeEach and test invocations will
- * have access to the following:
- * * this.owner - This exposes the standard "owner API" for the test environment.
- * * this.set / this.setProperties - Allows setting values on the test context.
- * * this.get / this.getProperties - Retrieves values from the test context.
- */
-export function setupTest(hooks: NestedHooks, options?: SetupTestOptions): void;
-
-export class QUnitAdapter extends EmberTestAdapter {}
-
-export { module, test, skip, only, todo } from 'qunit';
-
-interface QUnitStartOptions {
-  /**
-   * If `false` the test container will not be setup based on `devmode`,
-   * `dockcontainer`, or `nocontainer` URL params.
-   */
-  setupTestContainer?: boolean | undefined;
-
-  /**
-   * If `false` tests will not be automatically started (you must run
-   * `QUnit.start()` to kick them off).
-   */
-  startTests?: boolean | undefined;
-
-  /**
-   * If `false` the default Ember.Test adapter will not be updated.
-   */
-  setupTestAdapter?: boolean | undefined;
-
-  /**
-   * `false` opts out of the default behavior of setting `Ember.testing`
-   * to `true` before all tests and back to `false` after each test will.
-   */
-  setupEmberTesting?: boolean | undefined;
-
-  /**
-   * If `false` test isolation validation will be disabled.
-   */
-  setupTestIsolationValidation?: boolean | undefined;
-}
-
-export function setupEmberOnerrorValidation(): void;
-
-export function start(options?: QUnitStartOptions): void;
-
-// SAFETY: all of the `TC extends TestContext` generics below are just wildly,
-// impossibly unsafe. QUnit cannot -- ever! -- guarantee that the test context
-// is properly set up in a type-safe way to match this. However, it is the only
-// way to handle setting state in a TS-visible way prior to Ember RFC 0785,
-// which is slooooowly rolling out across the ecosystem in conjunction with the
-// `<template>` feature.
-
-declare global {
-  // NOTE: disables `no-unnecessary-generics` inline because, unfortunately,
-  // the design of Ember's test tooling (and indeed *QUnit's* test system)
-  // requires that we allow users to update the type of the context of the
-  // test. This is indeed strictly *wrong*! However, changing it will require
-  // changing how Ember handles testing. See [the PR][pr] for further details.
-  //
-  // [pr]: https://github.com/DefinitelyTyped/DefinitelyTyped/pull/56494
-
-  interface NestedHooks {
-    /**
-     * Runs after the last test. If additional tests are defined after the
-     * module's queue has emptied, it will not run this hook again.
-     */
-    after<TC extends TestContext>(
-      fn: (this: TC, assert: Assert) => void | Promise<void>
-    ): void;
-
-    /**
-     * Runs after each test.
-     */
-    afterEach<TC extends TestContext>(
-      fn: (this: TC, assert: Assert) => void | Promise<void>
-    ): void;
-
-    /**
-     * Runs before the first test.
-     */
-    // SAFETY: this is just wildly, impossibly unsafe. QUnit cannot -- ever! --
-    before<TC extends TestContext>(
-      fn: (this: TC, assert: Assert) => void | Promise<void>
-    ): void;
-
-    /**
-     * Runs before each test.
-     */
-    // SAFETY: this is just wildly, impossibly unsafe. QUnit cannot -- ever! --
-    beforeEach<TC extends TestContext>(
-      fn: (this: TC, assert: Assert) => void | Promise<void>
-    ): void;
-  }
-
-  interface QUnit {
-    /**
-     * Adds a test to exclusively run, preventing all other tests from running.
-     *
-     * Use this method to focus your test suite on a specific test. QUnit.only
-     * will cause any other tests in your suite to be ignored.
-     *
-     * Note, that if more than one QUnit.only is present only the first instance
-     * will run.
-     *
-     * This is an alternative to filtering tests to run in the HTML reporter. It
-     * is especially useful when you use a console reporter or in a codebase
-     * with a large set of long running tests.
-     *
-     * @param name Title of unit being tested
-     * @param callback Function to close over assertions
-     */
-    // SAFETY: this is just wildly, impossibly unsafe. QUnit cannot -- ever! --
-    // provide this guarantee. However, it's also the only way to support TS
-    // in tests in Ember until we move the community over entirely to using
-    // `<template>` and local scope.
-    only<TC extends TestContext>(
-      name: string,
-      callback: (this: TC, assert: Assert) => void | Promise<unknown>
-    ): void;
-
-    /**
-     * Use this method to test a unit of code which is still under development (in a “todo” state).
-     * The test will pass as long as one failing assertion is present.
-     *
-     * If all assertions pass, then the test will fail signaling that `QUnit.todo` should
-     * be replaced by `QUnit.test`.
-     *
-     * @param name Title of unit being tested
-     * @param callback Function to close over assertions
-     */
-    // SAFETY: this is just wildly, impossibly unsafe. QUnit cannot -- ever! --
-    // provide this guarantee. However, it's also the only way to support TS
-    // in tests in Ember until we move the community over entirely to using
-    // `<template>` and local scope.
-    todo<TC extends TestContext>(
-      name: string,
-      callback: (this: TC, assert: Assert) => void | Promise<unknown>
-    ): void;
-
-    /**
-     * Adds a test like object to be skipped.
-     *
-     * Use this method to replace QUnit.test() instead of commenting out entire
-     * tests.
-     *
-     * This test's prototype will be listed on the suite as a skipped test,
-     * ignoring the callback argument and the respective global and module's
-     * hooks.
-     *
-     * @param name Title of unit being tested
-     * @param callback Function to close over assertions
-     */
-    // SAFETY: this is just wildly, impossibly unsafe. QUnit cannot -- ever! --
-    // provide this guarantee. However, it's also the only way to support TS
-    // in tests in Ember until we move the community over entirely to using
-    // `<template>` and local scope.
-    skip<TC extends TestContext>(
-      name: string,
-      callback?: (this: TC, assert: Assert) => void | Promise<unknown>
-    ): void;
-  }
-
-  namespace QUnit {
-    interface TestFunction {
-      // SAFETY: this is just wildly, impossibly unsafe. QUnit cannot -- ever! --
-      // provide this guarantee. However, it's also the only way to support TS
-      // in tests in Ember until we move the community over entirely to using
-      // `<template>` and local scope.
-      <TC extends TestContext>(
-        name: string,
-        callback: (this: TC, assert: Assert) => void | Promise<unknown>
-      ): void;
-    }
-
-    interface SkipFunction {
-      <TC extends TestContext>(
-        name: string,
-        callback?: (this: TC, assert: Assert) => void | Promise<unknown>
-      ): void;
-    }
-
-    interface TodoFunction {
-      <TC extends TestContext>(
-        name: string,
-        callback?: (this: TC, assert: Assert) => void | Promise<unknown>
-      ): void;
-    }
-
-    interface OnlyFunction {
-      <TC extends TestContext>(
-        name: string,
-        callback: (this: TC, assert: Assert) => void | Promise<unknown>
-      ): void;
-    }
-
-    interface EachFunction {
-      <TC extends TestContext, T>(
-        name: string,
-        dataset: T[] | Record<string, T>,
-        callback: (this: TC, assert: Assert, data: T) => void | Promise<unknown>
-      ): void;
-    }
-  }
-}
-
-}

package/external-types/ember-qunit/types/local-types.d.ts

@@ -1,5 +0,0 @@
-declare module 'ember-qunit/local-types' {
-import 'ember-source/types';
-import 'ember-source/types/preview';
-
-}

package/external-types/ember-qunit/types/test-loader.d.ts

@@ -1,4 +0,0 @@
-declare module 'ember-qunit/test-loader' {
-export function loadTests(): void;
-
-}