@discourse/types 0.0.2 → 2026.1.0-2709d36

package/external-types/@floating-ui__dom/dist/floating-ui.dom.d.ts

@@ -1,359 +0,0 @@
-declare module '@floating-ui/dom' {
-import { AlignedPlacement } from '@floating-ui/core';
-import { Alignment } from '@floating-ui/core';
-import type { ArrowOptions as ArrowOptions_2 } from '@floating-ui/core';
-import type { AutoPlacementOptions as AutoPlacementOptions_2 } from '@floating-ui/core';
-import { Axis } from '@floating-ui/core';
-import { ClientRectObject } from '@floating-ui/core';
-import type { ComputePositionConfig as ComputePositionConfig_2 } from '@floating-ui/core';
-import { ComputePositionReturn } from '@floating-ui/core';
-import { Coords } from '@floating-ui/core';
-import type { DetectOverflowOptions as DetectOverflowOptions_2 } from '@floating-ui/core';
-import { Dimensions } from '@floating-ui/core';
-import { ElementContext } from '@floating-ui/core';
-import { ElementRects } from '@floating-ui/core';
-import type { FlipOptions as FlipOptions_2 } from '@floating-ui/core';
-import { getOverflowAncestors } from '@floating-ui/utils/dom';
-import type { HideOptions as HideOptions_2 } from '@floating-ui/core';
-import { InlineOptions } from '@floating-ui/core';
-import { Length } from '@floating-ui/core';
-import { LimitShiftOptions } from '@floating-ui/core';
-import type { Middleware as Middleware_2 } from '@floating-ui/core';
-import { MiddlewareData } from '@floating-ui/core';
-import { MiddlewareReturn } from '@floating-ui/core';
-import type { MiddlewareState as MiddlewareState_2 } from '@floating-ui/core';
-import { Padding } from '@floating-ui/core';
-import { Placement } from '@floating-ui/core';
-import { Rect } from '@floating-ui/core';
-import { RootBoundary } from '@floating-ui/core';
-import type { ShiftOptions as ShiftOptions_2 } from '@floating-ui/core';
-import { Side } from '@floating-ui/core';
-import { SideObject } from '@floating-ui/core';
-import type { SizeOptions as SizeOptions_2 } from '@floating-ui/core';
-import { Strategy } from '@floating-ui/core';
-
-export { AlignedPlacement }
-
-export { Alignment }
-
-/**
- * Provides data to position an inner element of the floating element so that it
- * appears centered to the reference element.
- * @see https://floating-ui.com/docs/arrow
- */
-export declare const arrow: (options: ArrowOptions | Derivable<ArrowOptions>) => Middleware;
-
-export declare type ArrowOptions = Prettify<Omit<ArrowOptions_2, 'element'> & {
-    element: Element;
-}>;
-
-/**
- * Optimizes the visibility of the floating element by choosing the placement
- * that has the most space available automatically, without needing to specify a
- * preferred placement. Alternative to `flip`.
- * @see https://floating-ui.com/docs/autoPlacement
- */
-export declare const autoPlacement: (options?: AutoPlacementOptions | Derivable<AutoPlacementOptions>) => Middleware;
-
-export declare type AutoPlacementOptions = Prettify<Omit<AutoPlacementOptions_2, 'boundary'> & DetectOverflowOptions>;
-
-/**
- * Automatically updates the position of the floating element when necessary.
- * Should only be called when the floating element is mounted on the DOM or
- * visible on the screen.
- * @returns cleanup function that should be invoked when the floating element is
- * removed from the DOM or hidden from the screen.
- * @see https://floating-ui.com/docs/autoUpdate
- */
-export declare function autoUpdate(reference: ReferenceElement, floating: FloatingElement, update: () => void, options?: AutoUpdateOptions): () => void;
-
-export declare interface AutoUpdateOptions {
-    /**
-     * Whether to update the position when an overflow ancestor is scrolled.
-     * @default true
-     */
-    ancestorScroll?: boolean;
-    /**
-     * Whether to update the position when an overflow ancestor is resized. This
-     * uses the native `resize` event.
-     * @default true
-     */
-    ancestorResize?: boolean;
-    /**
-     * Whether to update the position when either the reference or floating
-     * elements resized. This uses a `ResizeObserver`.
-     * @default true
-     */
-    elementResize?: boolean;
-    /**
-     * Whether to update the position when the reference relocated on the screen
-     * due to layout shift.
-     * @default true
-     */
-    layoutShift?: boolean;
-    /**
-     * Whether to update on every animation frame if necessary. Only use if you
-     * need to update the position in response to an animation using transforms.
-     * @default false
-     */
-    animationFrame?: boolean;
-}
-
-export { Axis }
-
-/**
- * The clipping boundary area of the floating element.
- */
-export declare type Boundary = 'clippingAncestors' | Element | Array<Element> | Rect;
-
-export { ClientRectObject }
-
-/**
- * Computes the `x` and `y` coordinates that will place the floating element
- * next to a given reference element.
- */
-export declare const computePosition: (reference: ReferenceElement, floating: FloatingElement, options?: Partial<ComputePositionConfig>) => Promise<ComputePositionReturn>;
-
-export declare type ComputePositionConfig = Prettify<Omit<ComputePositionConfig_2, 'middleware' | 'platform'> & {
-    /**
-     * Array of middleware objects to modify the positioning or provide data for
-     * rendering.
-     */
-    middleware?: Array<Middleware | null | undefined | false>;
-    /**
-     * Custom or extended platform object.
-     */
-    platform?: Platform;
-}>;
-
-export { ComputePositionReturn }
-
-export { Coords }
-
-export declare type Derivable<T> = (state: MiddlewareState) => T;
-
-/**
- * Resolves with an object of overflow side offsets that determine how much the
- * element is overflowing a given clipping boundary on each side.
- * - positive = overflowing the boundary by that number of pixels
- * - negative = how many pixels left before it will overflow
- * - 0 = lies flush with the boundary
- * @see https://floating-ui.com/docs/detectOverflow
- */
-export declare const detectOverflow: (state: MiddlewareState, options?: DetectOverflowOptions | Derivable<DetectOverflowOptions>) => Promise<SideObject>;
-
-export declare type DetectOverflowOptions = Prettify<Omit<DetectOverflowOptions_2, 'boundary'> & {
-    boundary?: Boundary;
-}>;
-
-export { Dimensions }
-
-export { ElementContext }
-
-export { ElementRects }
-
-export declare interface Elements {
-    reference: ReferenceElement;
-    floating: FloatingElement;
-}
-
-/**
- * Optimizes the visibility of the floating element by flipping the `placement`
- * in order to keep it in view when the preferred placement(s) will overflow the
- * clipping boundary. Alternative to `autoPlacement`.
- * @see https://floating-ui.com/docs/flip
- */
-export declare const flip: (options?: FlipOptions | Derivable<FlipOptions>) => Middleware;
-
-export declare type FlipOptions = Prettify<Omit<FlipOptions_2, 'boundary'> & DetectOverflowOptions>;
-
-export declare type FloatingElement = HTMLElement;
-
-export { getOverflowAncestors }
-
-/**
- * Provides data to hide the floating element in applicable situations, such as
- * when it is not in the same clipping context as the reference element.
- * @see https://floating-ui.com/docs/hide
- */
-export declare const hide: (options?: HideOptions | Derivable<HideOptions>) => Middleware;
-
-export declare type HideOptions = Prettify<Omit<HideOptions_2, 'boundary'> & DetectOverflowOptions>;
-
-/**
- * Provides improved positioning for inline reference elements that can span
- * over multiple lines, such as hyperlinks or range selections.
- * @see https://floating-ui.com/docs/inline
- */
-export declare const inline: (options?: InlineOptions | Derivable<InlineOptions>) => Middleware;
-
-export { InlineOptions }
-
-export { Length }
-
-/**
- * Built-in `limiter` that will stop `shift()` at a certain point.
- */
-export declare const limitShift: (options?: LimitShiftOptions | Derivable<LimitShiftOptions>) => {
-    options: any;
-    fn: (state: MiddlewareState) => Coords;
-};
-
-export { LimitShiftOptions }
-
-export declare type Middleware = Prettify<Omit<Middleware_2, 'fn'> & {
-    fn(state: MiddlewareState): Promisable<MiddlewareReturn>;
-}>;
-
-/**
- * @deprecated use `MiddlewareState` instead.
- */
-export declare type MiddlewareArguments = MiddlewareState;
-
-export { MiddlewareData }
-
-export { MiddlewareReturn }
-
-export declare type MiddlewareState = Prettify<Omit<MiddlewareState_2, 'elements'> & {
-    elements: Elements;
-}>;
-
-export declare interface NodeScroll {
-    scrollLeft: number;
-    scrollTop: number;
-}
-
-/**
- * Modifies the placement by translating the floating element along the
- * specified axes.
- * A number (shorthand for `mainAxis` or distance), or an axes configuration
- * object may be passed.
- * @see https://floating-ui.com/docs/offset
- */
-export declare const offset: (options?: OffsetOptions) => Middleware;
-
-export declare type OffsetOptions = OffsetValue | Derivable<OffsetValue>;
-
-declare type OffsetValue = number | {
-    /**
-     * The axis that runs along the side of the floating element. Represents
-     * the distance (gutter or margin) between the reference and floating
-     * element.
-     * @default 0
-     */
-    mainAxis?: number;
-    /**
-     * The axis that runs along the alignment of the floating element.
-     * Represents the skidding between the reference and floating element.
-     * @default 0
-     */
-    crossAxis?: number;
-    /**
-     * The same axis as `crossAxis` but applies only to aligned placements
-     * and inverts the `end` alignment. When set to a number, it overrides the
-     * `crossAxis` value.
-     *
-     * A positive number will move the floating element in the direction of
-     * the opposite edge to the one that is aligned, while a negative number
-     * the reverse.
-     * @default null
-     */
-    alignmentAxis?: number | null;
-};
-
-export { Padding }
-
-export { Placement }
-
-export declare interface Platform {
-    getElementRects: (args: {
-        reference: ReferenceElement;
-        floating: FloatingElement;
-        strategy: Strategy;
-    }) => Promisable<ElementRects>;
-    getClippingRect: (args: {
-        element: Element;
-        boundary: Boundary;
-        rootBoundary: RootBoundary;
-        strategy: Strategy;
-    }) => Promisable<Rect>;
-    getDimensions: (element: Element) => Promisable<Dimensions>;
-    convertOffsetParentRelativeRectToViewportRelativeRect: (args: {
-        elements?: Elements;
-        rect: Rect;
-        offsetParent: Element;
-        strategy: Strategy;
-    }) => Promisable<Rect>;
-    getOffsetParent: (element: Element, polyfill?: (element: HTMLElement) => Element | null) => Promisable<Element | Window>;
-    isElement: (value: unknown) => Promisable<boolean>;
-    getDocumentElement: (element: Element) => Promisable<HTMLElement>;
-    getClientRects: (element: Element) => Promisable<Array<ClientRectObject>>;
-    isRTL: (element: Element) => Promisable<boolean>;
-    getScale: (element: HTMLElement) => Promisable<{
-        x: number;
-        y: number;
-    }>;
-}
-
-export declare const platform: Platform;
-
-declare type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-
-declare type Promisable<T> = T | Promise<T>;
-
-export { Rect }
-
-export declare type ReferenceElement = Element | VirtualElement;
-
-export { RootBoundary }
-
-/**
- * Optimizes the visibility of the floating element by shifting it in order to
- * keep it in view when it will overflow the clipping boundary.
- * @see https://floating-ui.com/docs/shift
- */
-export declare const shift: (options?: ShiftOptions | Derivable<ShiftOptions>) => Middleware;
-
-export declare type ShiftOptions = Prettify<Omit<ShiftOptions_2, 'boundary'> & DetectOverflowOptions>;
-
-export { Side }
-
-export { SideObject }
-
-/**
- * Provides data that allows you to change the size of the floating element —
- * for instance, prevent it from overflowing the clipping boundary or match the
- * width of the reference element.
- * @see https://floating-ui.com/docs/size
- */
-export declare const size: (options?: SizeOptions | Derivable<SizeOptions>) => Middleware;
-
-export declare type SizeOptions = Prettify<Omit<SizeOptions_2, 'apply' | 'boundary'> & DetectOverflowOptions & {
-    /**
-     * Function that is called to perform style mutations to the floating element
-     * to change its size.
-     * @default undefined
-     */
-    apply?(args: MiddlewareState & {
-        availableWidth: number;
-        availableHeight: number;
-    }): Promisable<void>;
-}>;
-
-export { Strategy }
-
-/**
- * Custom positioning reference element.
- * @see https://floating-ui.com/docs/virtual-elements
- */
-export declare interface VirtualElement {
-    getBoundingClientRect(): ClientRectObject;
-    getClientRects?(): Array<ClientRectObject> | DOMRectList;
-    contextElement?: Element;
-}
-
-export { }
-
-}

package/external-types/@glimmer__component/dist/-private/base-component-manager.d.ts

@@ -1,15 +0,0 @@
-declare module '@glimmer/component/-private/base-component-manager' {
-import type { Arguments, ComponentManager, ComponentCapabilities } from '@glimmer/interfaces';
-import { type default as BaseComponent } from './component';
-export interface Constructor<T> {
-    new (owner: unknown, args: Record<string, unknown>): T;
-}
-export default abstract class BaseComponentManager<GlimmerComponent extends BaseComponent> implements ComponentManager<GlimmerComponent> {
-    abstract capabilities: ComponentCapabilities;
-    private owner;
-    constructor(owner: unknown);
-    createComponent(ComponentClass: Constructor<GlimmerComponent>, args: Arguments): GlimmerComponent;
-    getContext(component: GlimmerComponent): GlimmerComponent;
-}
-
-}

package/external-types/@glimmer__component/dist/-private/component.d.ts

@@ -1,247 +0,0 @@
-declare module '@glimmer/component/-private/component' {
-export declare function setDestroying(component: GlimmerComponent<object>): void;
-export declare function setDestroyed(component: GlimmerComponent<object>): void;
-interface ArgsSetMap extends WeakMap<Args<unknown>, boolean> {
-    get<S>(key: Args<S>): boolean | undefined;
-    set<S>(key: Args<S>, value: boolean): this;
-    has<S>(key: Args<S>): boolean;
-}
-export declare let ARGS_SET: ArgsSetMap;
-declare const Empty: unique symbol;
-/**
- * This provides us a way to have a "fallback" which represents an empty object,
- * without the downsides of how TS treats `{}`. Specifically: this will
- * correctly leverage "excess property checking" so that, given a component
- * which has no named args, if someone invokes it with any named args, they will
- * get a type error.
- *
- * @internal This is exported so declaration emit works (if it were not emitted,
- *   declarations which fall back to it would not work). It is *not* intended for
- *   public usage, and the specific mechanics it uses may change at any time.
- *   The location of this export *is* part of the public API, because moving it
- *   will break existing declarations, but is not legal for end users to import
- *   themselves, so ***DO NOT RELY ON IT***.
- */
-export type EmptyObject = {
-    [Empty]?: true;
-};
-type GetOrElse<Obj, K extends PropertyKey, Fallback> = Obj extends {
-    [Key in K]: infer U;
-} ? U : Fallback;
-/** Given a signature `S`, get back the `Args` type. */
-type ArgsFor<S> = S extends {
-    Args: infer Args;
-} ? Args extends {
-    Named?: object;
-    Positional?: unknown[];
-} ? {
-    Named: GetOrElse<S['Args'], 'Named', EmptyObject>;
-    Positional: GetOrElse<S['Args'], 'Positional', []>;
-} : {
-    Named: S['Args'];
-    Positional: [];
-} : {
-    Named: EmptyObject;
-    Positional: [];
-};
-type _ExpandSignature<T> = {
-    Element: GetOrElse<T, 'Element', null>;
-    Args: keyof T extends 'Args' | 'Element' | 'Blocks' ? ArgsFor<T> : {
-        Named: T;
-        Positional: [];
-    };
-    Blocks: T extends {
-        Blocks: infer Blocks;
-    } ? {
-        [Block in keyof Blocks]: Blocks[Block] extends unknown[] ? {
-            Params: {
-                Positional: Blocks[Block];
-            };
-        } : Blocks[Block];
-    } : EmptyObject;
-};
-/**
- * Given any allowed shorthand form of a signature, desugars it to its full
- * expanded type.
- *
- * @internal This is only exported so we can avoid duplicating it in
- *   [Glint](https://github.com/typed-ember/glint) or other such tooling. It is
- *   *not* intended for public usage, and the specific mechanics it uses may
- *   change at any time. Although the signature produced by is part of Glimmer's
- *   public API the existence and mechanics of this specific symbol are *not*,
- *   so ***DO NOT RELY ON IT***.
- */
-export type ExpandSignature<T> = T extends any ? _ExpandSignature<T> : never;
-/**
- * @internal we use this type for convenience internally; inference means users
- *   should not normally need to name it
- */
-export type Args<S> = ExpandSignature<S>['Args']['Named'];
-/**
- * The `Component` class defines an encapsulated UI element that is rendered to
- * the DOM. A component is made up of a template and, optionally, this component
- * object.
- *
- * ## Defining a Component
- *
- * To define a component, subclass `Component` and add your own properties,
- * methods and lifecycle hooks:
- *
- * ```ts
- * import Component from '@glimmer/component';
- *
- * export default class extends Component {
- * }
- * ```
- *
- * ## Lifecycle Hooks
- *
- * Lifecycle hooks allow you to respond to changes to a component, such as when
- * it gets created, rendered, updated or destroyed. To add a lifecycle hook to a
- * component, implement the hook as a method on your component subclass.
- *
- * For example, to be notified when Glimmer has rendered your component so you
- * can attach a legacy jQuery plugin, implement the `didInsertElement()` method:
- *
- * ```ts
- * import Component from '@glimmer/component';
- *
- * export default class extends Component {
- *   didInsertElement() {
- *     $(this.element).pickadate();
- *   }
- * }
- * ```
- *
- * ## Data for Templates
- *
- * `Component`s have two different kinds of data, or state, that can be
- * displayed in templates:
- *
- * 1. Arguments
- * 2. Properties
- *
- * Arguments are data that is passed in to a component from its parent
- * component. For example, if I have a `UserGreeting` component, I can pass it
- * a name and greeting to use:
- *
- * ```hbs
- * <UserGreeting @name="Ricardo" @greeting="Olá" />
- * ```
- *
- * Inside my `UserGreeting` template, I can access the `@name` and `@greeting`
- * arguments that I've been given:
- *
- * ```hbs
- * {{@greeting}}, {{@name}}!
- * ```
- *
- * Arguments are also available inside my component:
- *
- * ```ts
- * console.log(this.args.greeting); // prints "Olá"
- * ```
- *
- * Properties, on the other hand, are internal to the component and declared in
- * the class. You can use properties to store data that you want to show in the
- * template, or pass to another component as an argument.
- *
- * ```ts
- * import Component from '@glimmer/component';
- *
- * export default class extends Component {
- *   user = {
- *     name: 'Robbie'
- *   }
- * }
- * ```
- *
- * In the above example, we've defined a component with a `user` property that
- * contains an object with its own `name` property.
- *
- * We can render that property in our template:
- *
- * ```hbs
- * Hello, {{user.name}}!
- * ```
- *
- * We can also take that property and pass it as an argument to the
- * `UserGreeting` component we defined above:
- *
- * ```hbs
- * <UserGreeting @greeting="Hello" @name={{user.name}} />
- * ```
- *
- * ## Arguments vs. Properties
- *
- * Remember, arguments are data that was given to your component by its parent
- * component, and properties are data your component has defined for itself.
- *
- * You can tell the difference between arguments and properties in templates
- * because arguments always start with an `@` sign (think "A is for arguments"):
- *
- * ```hbs
- * {{@firstName}}
- * ```
- *
- * We know that `@firstName` came from the parent component, not the current
- * component, because it starts with `@` and is therefore an argument.
- *
- * On the other hand, if we see:
- *
- * ```hbs
- * {{name}}
- * ```
- *
- * We know that `name` is a property on the component. If we want to know where
- * the data is coming from, we can go look at our component class to find out.
- *
- * Inside the component itself, arguments always show up inside the component's
- * `args` property. For example, if `{{@firstName}}` is `Tom` in the template,
- * inside the component `this.args.firstName` would also be `Tom`.
- */
-export default class GlimmerComponent<S = unknown> {
-    /**
-     * Constructs a new component and assigns itself the passed properties. You
-     * should not construct new components yourself. Instead, Glimmer will
-     * instantiate new components automatically as it renders.
-     *
-     * @param owner
-     * @param args
-     */
-    constructor(owner: unknown, args: Args<S>);
-    /**
-     * Named arguments passed to the component from its parent component.
-     * They can be accessed in JavaScript via `this.args.argumentName` and in the template via `@argumentName`.
-     *
-     * Say you have the following component, which will have two `args`, `firstName` and `lastName`:
-     *
-     * ```hbs
-     * <my-component @firstName="Arthur" @lastName="Dent" />
-     * ```
-     *
-     * If you needed to calculate `fullName` by combining both of them, you would do:
-     *
-     * ```ts
-     * didInsertElement() {
-     *   console.log(`Hi, my full name is ${this.args.firstName} ${this.args.lastName}`);
-     * }
-     * ```
-     *
-     * While in the template you could do:
-     *
-     * ```hbs
-     * <p>Welcome, {{@firstName}} {{@lastName}}!</p>
-     * ```
-     */
-    readonly args: Readonly<Args<S>>;
-    get isDestroying(): boolean;
-    get isDestroyed(): boolean;
-    /**
-     * Called before the component has been removed from the DOM.
-     */
-    willDestroy(): void;
-}
-export {};
-
-}

package/external-types/@glimmer__component/dist/-private/ember-component-manager.d.ts

@@ -1,20 +0,0 @@
-declare module '@glimmer/component/-private/ember-component-manager' {
-import BaseComponentManager from './base-component-manager';
-import { type default as GlimmerComponent } from './component';
-import type { Arguments } from '@glimmer/interfaces';
-/**
- * This component manager runs in Ember.js environments and extends the base component manager to:
- *
- * 1. Properly destroy the component's associated `meta` data structure
- * 2. Schedule destruction using Ember's runloop
- */
-declare class EmberGlimmerComponentManager extends BaseComponentManager<GlimmerComponent> {
-    capabilities: any;
-    destroyComponent(component: GlimmerComponent): void;
-}
-interface EmberGlimmerComponentManager {
-    updateComponent?: (component: GlimmerComponent, args: Arguments) => void;
-}
-export default EmberGlimmerComponentManager;
-
-}