@discourse/types 2026.8.0-fb9247e0 → 2026.9.0-c0ef3a11

package/external-types/floating-ui__dom/index.d.ts

@@ -1,37 +1,37 @@
 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 { detectOverflow as detectOverflow_2 } 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';
+	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 { detectOverflow as detectOverflow_2 } 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 }
 	
@@ -42,9 +42,9 @@ declare module '@floating-ui/dom' {
 	 * appears centered to the reference element.
 	 * @see https://floating-ui.com/docs/arrow
 	 */
-	export const arrow: (options: ArrowOptions | Derivable<ArrowOptions>) => Middleware;
+	export  const arrow: (options: ArrowOptions | Derivable<ArrowOptions>) => Middleware;
 	
-	export type ArrowOptions = Prettify<Omit<ArrowOptions_2, 'element'> & {
+	export  type ArrowOptions = Prettify<Omit<ArrowOptions_2, 'element'> & {
 	    element: Element;
 	}>;
 	
@@ -54,9 +54,9 @@ declare module '@floating-ui/dom' {
 	 * preferred placement. Alternative to `flip`.
 	 * @see https://floating-ui.com/docs/autoPlacement
 	 */
-	export const autoPlacement: (options?: AutoPlacementOptions | Derivable<AutoPlacementOptions>) => Middleware;
+	export  const autoPlacement: (options?: AutoPlacementOptions | Derivable<AutoPlacementOptions>) => Middleware;
 	
-	export type AutoPlacementOptions = Prettify<Omit<AutoPlacementOptions_2, 'boundary'> & DetectOverflowOptions>;
+	export  type AutoPlacementOptions = Prettify<Omit<AutoPlacementOptions_2, 'boundary'> & DetectOverflowOptions>;
 	
 	/**
 	 * Automatically updates the position of the floating element when necessary.
@@ -66,46 +66,50 @@ declare module '@floating-ui/dom' {
 	 * removed from the DOM or hidden from the screen.
 	 * @see https://floating-ui.com/docs/autoUpdate
 	 */
-	export function autoUpdate(reference: ReferenceElement, floating: FloatingElement | null, update: () => void, options?: AutoUpdateOptions): () => void;
+	export  function autoUpdate(reference: ReferenceElement, floating: FloatingElement | null, update: () => void, options?: AutoUpdateOptions): () => void;
 	
-	export interface AutoUpdateOptions {
+	export  interface AutoUpdateOptions {
 	    /**
 	     * Whether to update the position when an overflow ancestor is scrolled.
 	     * @default true
 	     */
-	    ancestorScroll?: boolean;
+	    ancestorScroll?: boolean | undefined;
 	    /**
 	     * Whether to update the position when an overflow ancestor is resized. This
 	     * uses the native `resize` event.
 	     * @default true
 	     */
-	    ancestorResize?: boolean;
+	    ancestorResize?: boolean | undefined;
 	    /**
 	     * Whether to update the position when either the reference or floating
 	     * elements resized. This uses a `ResizeObserver`.
 	     * @default true
 	     */
-	    elementResize?: boolean;
+	    elementResize?: boolean | undefined;
 	    /**
 	     * Whether to update the position when the reference relocated on the screen
 	     * due to layout shift.
 	     * @default true
 	     */
-	    layoutShift?: boolean;
+	    layoutShift?: boolean | undefined;
 	    /**
 	     * 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;
+	    animationFrame?: boolean | undefined;
 	}
 	
 	export { Axis }
 	
+	 type BivariantCallback<T extends (...args: any[]) => any> = {
+	    bivariance(...args: Parameters<T>): ReturnType<T>;
+	}['bivariance'];
+	
 	/**
 	 * The clipping boundary area of the floating element.
 	 */
-	export type Boundary = 'clippingAncestors' | Element | Array<Element> | Rect;
+	export  type Boundary = 'clippingAncestors' | Element | Array<Element> | Rect;
 	
 	export { ClientRectObject }
 	
@@ -113,25 +117,25 @@ declare module '@floating-ui/dom' {
 	 * Computes the `x` and `y` coordinates that will place the floating element
 	 * next to a given reference element.
 	 */
-	export const computePosition: (reference: ReferenceElement, floating: FloatingElement, options?: Partial<ComputePositionConfig>) => Promise<ComputePositionReturn>;
+	export  const computePosition: (reference: ReferenceElement, floating: FloatingElement, options?: Partial<ComputePositionConfig>) => Promise<ComputePositionReturn>;
 	
-	export type ComputePositionConfig = Prettify<Omit<ComputePositionConfig_2, 'middleware' | 'platform'> & {
+	export  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>;
+	    middleware?: Array<Middleware | null | undefined | false> | undefined;
 	    /**
 	     * Custom or extended platform object.
 	     */
-	    platform?: Platform;
+	    platform?: Platform | undefined;
 	}>;
 	
 	export { ComputePositionReturn }
 	
 	export { Coords }
 	
-	export type Derivable<T> = (state: MiddlewareState) => T;
+	export  type Derivable<T> = (state: MiddlewareState) => T;
 	
 	/**
 	 * Resolves with an object of overflow side offsets that determine how much the
@@ -141,10 +145,10 @@ declare module '@floating-ui/dom' {
 	 * - 0 = lies flush with the boundary
 	 * @see https://floating-ui.com/docs/detectOverflow
 	 */
-	export const detectOverflow: (state: MiddlewareState, options?: DetectOverflowOptions | Derivable<DetectOverflowOptions>) => Promise<SideObject>;
+	export  const detectOverflow: (state: MiddlewareState, options?: DetectOverflowOptions | Derivable<DetectOverflowOptions>) => Promise<SideObject>;
 	
-	export type DetectOverflowOptions = Prettify<Omit<DetectOverflowOptions_2, 'boundary'> & {
-	    boundary?: Boundary;
+	export  type DetectOverflowOptions = Prettify<Omit<DetectOverflowOptions_2, 'boundary'> & {
+	    boundary?: Boundary | undefined;
 	}>;
 	
 	export { Dimensions }
@@ -153,7 +157,7 @@ declare module '@floating-ui/dom' {
 	
 	export { ElementRects }
 	
-	export interface Elements {
+	export  interface Elements {
 	    reference: ReferenceElement;
 	    floating: FloatingElement;
 	}
@@ -164,11 +168,11 @@ declare module '@floating-ui/dom' {
 	 * clipping boundary. Alternative to `autoPlacement`.
 	 * @see https://floating-ui.com/docs/flip
 	 */
-	export const flip: (options?: FlipOptions | Derivable<FlipOptions>) => Middleware;
+	export  const flip: (options?: FlipOptions | Derivable<FlipOptions>) => Middleware;
 	
-	export type FlipOptions = Prettify<Omit<FlipOptions_2, 'boundary'> & DetectOverflowOptions>;
+	export  type FlipOptions = Prettify<Omit<FlipOptions_2, 'boundary'> & DetectOverflowOptions>;
 	
-	export type FloatingElement = HTMLElement;
+	export  type FloatingElement = HTMLElement;
 	
 	export { getOverflowAncestors }
 	
@@ -177,16 +181,16 @@ declare module '@floating-ui/dom' {
 	 * when it is not in the same clipping context as the reference element.
 	 * @see https://floating-ui.com/docs/hide
 	 */
-	export const hide: (options?: HideOptions | Derivable<HideOptions>) => Middleware;
+	export  const hide: (options?: HideOptions | Derivable<HideOptions>) => Middleware;
 	
-	export type HideOptions = Prettify<Omit<HideOptions_2, 'boundary'> & DetectOverflowOptions>;
+	export  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 const inline: (options?: InlineOptions | Derivable<InlineOptions>) => Middleware;
+	export  const inline: (options?: InlineOptions | Derivable<InlineOptions>) => Middleware;
 	
 	export { InlineOptions }
 	
@@ -195,31 +199,31 @@ declare module '@floating-ui/dom' {
 	/**
 	 * Built-in `limiter` that will stop `shift()` at a certain point.
 	 */
-	export const limitShift: (options?: LimitShiftOptions | Derivable<LimitShiftOptions>) => {
+	export  const limitShift: (options?: LimitShiftOptions | Derivable<LimitShiftOptions>) => {
 	    options: any;
 	    fn: (state: MiddlewareState) => Coords;
 	};
 	
 	export { LimitShiftOptions }
 	
-	export type Middleware = Prettify<Omit<Middleware_2, 'fn'> & {
+	export  type Middleware = Prettify<Omit<Middleware_2, 'fn'> & {
 	    fn(state: MiddlewareState): Promisable<MiddlewareReturn>;
 	}>;
 	
 	/**
 	 * @deprecated use `MiddlewareState` instead.
 	 */
-	export type MiddlewareArguments = MiddlewareState;
+	export  type MiddlewareArguments = MiddlewareState;
 	
 	export { MiddlewareData }
 	
 	export { MiddlewareReturn }
 	
-	export type MiddlewareState = Prettify<Omit<MiddlewareState_2, 'elements'> & {
+	export  type MiddlewareState = Prettify<Omit<MiddlewareState_2, 'elements'> & {
 	    elements: Elements;
 	}>;
 	
-	export interface NodeScroll {
+	export  interface NodeScroll {
 	    scrollLeft: number;
 	    scrollTop: number;
 	}
@@ -231,22 +235,24 @@ declare module '@floating-ui/dom' {
 	 * object may be passed.
 	 * @see https://floating-ui.com/docs/offset
 	 */
-	export const offset: (options?: OffsetOptions) => Middleware;
+	export  const offset: (options?: OffsetOptions) => Middleware;
+	
+	export  type OffsetOptions = OffsetValue | Derivable<OffsetValue>;
 	
-	export type OffsetOptions = OffsetValue | Derivable<OffsetValue>; type OffsetValue = number | {
+	 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;
+	    mainAxis?: number | undefined;
 	    /**
 	     * The axis that runs along the alignment of the floating element.
 	     * Represents the skidding between the reference and floating element.
 	     * @default 0
 	     */
-	    crossAxis?: number;
+	    crossAxis?: number | undefined;
 	    /**
 	     * The same axis as `crossAxis` but applies only to aligned placements
 	     * and inverts the `end` alignment. When set to a number, it overrides the
@@ -257,14 +263,14 @@ declare module '@floating-ui/dom' {
 	     * the reverse.
 	     * @default null
 	     */
-	    alignmentAxis?: number | null;
+	    alignmentAxis?: number | null | undefined;
 	};
 	
 	export { Padding }
 	
 	export { Placement }
 	
-	export interface Platform {
+	export  interface Platform {
 	    getElementRects: (args: {
 	        reference: ReferenceElement;
 	        floating: FloatingElement;
@@ -278,7 +284,7 @@ declare module '@floating-ui/dom' {
 	    }) => Promisable<Rect>;
 	    getDimensions: (element: Element) => Promisable<Dimensions>;
 	    convertOffsetParentRelativeRectToViewportRelativeRect: (args: {
-	        elements?: Elements;
+	        elements?: Elements | undefined;
 	        rect: Rect;
 	        offsetParent: Element;
 	        strategy: Strategy;
@@ -292,16 +298,20 @@ declare module '@floating-ui/dom' {
 	        x: number;
 	        y: number;
 	    }>;
-	    detectOverflow?: typeof detectOverflow_2;
+	    detectOverflow?: typeof detectOverflow_2 | undefined;
 	}
 	
-	export const platform: Platform; type Prettify<T> = {
+	export  const platform: Platform;
+	
+	 type Prettify<T> = {
 	    [K in keyof T]: T[K];
-	} & {}; type Promisable<T> = T | Promise<T>;
+	} & {};
+	
+	 type Promisable<T> = T | Promise<T>;
 	
 	export { Rect }
 	
-	export type ReferenceElement = Element | VirtualElement;
+	export  type ReferenceElement = Element | VirtualElement;
 	
 	export { RootBoundary }
 	
@@ -310,9 +320,9 @@ declare module '@floating-ui/dom' {
 	 * keep it in view when it will overflow the clipping boundary.
 	 * @see https://floating-ui.com/docs/shift
 	 */
-	export const shift: (options?: ShiftOptions | Derivable<ShiftOptions>) => Middleware;
+	export  const shift: (options?: ShiftOptions | Derivable<ShiftOptions>) => Middleware;
 	
-	export type ShiftOptions = Prettify<Omit<ShiftOptions_2, 'boundary'> & DetectOverflowOptions>;
+	export  type ShiftOptions = Prettify<Omit<ShiftOptions_2, 'boundary'> & DetectOverflowOptions>;
 	
 	export { Side }
 	
@@ -324,18 +334,18 @@ declare module '@floating-ui/dom' {
 	 * width of the reference element.
 	 * @see https://floating-ui.com/docs/size
 	 */
-	export const size: (options?: SizeOptions | Derivable<SizeOptions>) => Middleware;
+	export  const size: (options?: SizeOptions | Derivable<SizeOptions>) => Middleware;
 	
-	export type SizeOptions = Prettify<Omit<SizeOptions_2, 'apply' | 'boundary'> & DetectOverflowOptions & {
+	export  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 & {
+	    apply?: BivariantCallback<(args: MiddlewareState & {
 	        availableWidth: number;
 	        availableHeight: number;
-	    }): Promisable<void>;
+	    }) => Promisable<void>> | undefined;
 	}>;
 	
 	export { Strategy }
@@ -344,10 +354,10 @@ declare module '@floating-ui/dom' {
 	 * Custom positioning reference element.
 	 * @see https://floating-ui.com/docs/virtual-elements
 	 */
-	export interface VirtualElement {
+	export  interface VirtualElement {
 	    getBoundingClientRect(): ClientRectObject;
-	    getClientRects?(): Array<ClientRectObject> | DOMRectList;
-	    contextElement?: Element;
+	    getClientRects?: (() => Array<ClientRectObject> | DOMRectList) | undefined;
+	    contextElement?: Element | undefined;
 	}
 	
 	export { }

package/external-types/floating-ui__dom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floating-ui/dom",
-  "version": "1.7.6",
+  "version": "1.8.0",
   "description": "Floating UI for the web",
   "publishConfig": {
     "access": "public"
@@ -43,8 +43,8 @@
     "positioning"
   ],
   "dependencies": {
-    "@floating-ui/core": "^1.7.5",
-    "@floating-ui/utils": "^0.2.11"
+    "@floating-ui/core": "^1.8.0",
+    "@floating-ui/utils": "^0.2.12"
   },
   "devDependencies": {
     "@types/react": "^18.3.19",
@@ -57,13 +57,14 @@
   },
   "scripts": {
     "lint": "eslint .",
-    "format": "prettier --write .",
+    "format": "prettier --ignore-path ../../.gitignore --write .",
     "clean": "rimraf dist out-tsc test-results",
     "dev": "vite",
     "build": "rollup -c",
     "build:api": "build-api --tsc tsconfig.lib.json",
     "test": "vitest run",
     "test:watch": "vitest watch",
+    "test:browser": "TEST_ENV=browser vitest --browser",
     "publint": "publint",
     "playwright": "playwright test ./test/functional",
     "typecheck": "tsc -b"

package/external-types/glimmer__component/index.d.ts

@@ -1,12 +1,13 @@
 declare module '@glimmer/component/-private/component' {
-	export function setDestroying(component: GlimmerComponent<object>): void;
-	export function setDestroyed(component: GlimmerComponent<object>): void;
+	export  function setDestroying(component: GlimmerComponent<object>): void;
+	export  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 let ARGS_SET: ArgsSetMap; const Empty: unique symbol;
+	export  let ARGS_SET: ArgsSetMap;
+	 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
@@ -245,8 +246,8 @@ declare module '@glimmer/component/-private/component' {
 
 }
 declare module '@glimmer/component' {
-	import _GlimmerComponent, { type Args } from '@glimmer/component/-private/component';
-	import { type default as Owner } from '@ember/owner';
+	import _GlimmerComponent, { type Args } from  '@glimmer/component/-private/component';
+	import { type default as Owner } from  '@ember/owner';
 	/**
 	  A component is a reusable UI element that consists of a `.hbs` template and an
 	  optional JavaScript class that defines its behavior. For example, someone
@@ -638,8 +639,8 @@ declare module '@glimmer/component' {
 
 }
 declare module '@glimmer/component/-private/base-component-manager' {
-	import type { Arguments, ComponentManager, ComponentCapabilities } from '@glimmer/interfaces';
-	import { type default as BaseComponent } from '@glimmer/component/-private/component';
+	import type { Arguments, ComponentManager, ComponentCapabilities } from  '@glimmer/interfaces';
+	import { type default as BaseComponent } from  '@glimmer/component/-private/component';
 	export interface Constructor<T> {
 	    new (owner: unknown, args: Record<string, unknown>): T;
 	}
@@ -653,9 +654,16 @@ declare module '@glimmer/component/-private/base-component-manager' {
 
 }
 declare module '@glimmer/component/-private/ember-component-manager' {
-	import BaseComponentManager from '@glimmer/component/-private/base-component-manager';
-	import { type default as GlimmerComponent } from '@glimmer/component/-private/component';
-	import type { Arguments } from '@glimmer/interfaces'; class EmberGlimmerComponentManager extends BaseComponentManager<GlimmerComponent> {
+	import BaseComponentManager from  '@glimmer/component/-private/base-component-manager';
+	import { type default as GlimmerComponent } from  '@glimmer/component/-private/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
+	 */
+	 class EmberGlimmerComponentManager extends BaseComponentManager<GlimmerComponent> {
 	    capabilities: any;
 	    destroyComponent(component: GlimmerComponent): void;
 	}