@discourse/types 0.0.1 → 2026.1.0-61b723a

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

@@ -0,0 +1,359 @@
+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/@floating-ui__dom/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@floating-ui/dom",
+  "version": "1.7.4",
+  "description": "Floating UI for the web",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/floating-ui.dom.umd.js",
+  "module": "./dist/floating-ui.dom.esm.js",
+  "unpkg": "./dist/floating-ui.dom.umd.min.js",
+  "types": "./dist/floating-ui.dom.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./dist/floating-ui.dom.d.mts",
+        "default": "./dist/floating-ui.dom.mjs"
+      },
+      "types": "./dist/floating-ui.dom.d.ts",
+      "module": "./dist/floating-ui.dom.esm.js",
+      "default": "./dist/floating-ui.dom.umd.js"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "author": "atomiks",
+  "license": "MIT",
+  "bugs": "https://github.com/floating-ui/floating-ui",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/floating-ui/floating-ui.git",
+    "directory": "packages/dom"
+  },
+  "homepage": "https://floating-ui.com",
+  "keywords": [
+    "tooltip",
+    "popover",
+    "dropdown",
+    "menu",
+    "popup",
+    "positioning"
+  ],
+  "dependencies": {
+    "@floating-ui/core": "^1.7.3",
+    "@floating-ui/utils": "^0.2.10"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.19",
+    "@types/react-dom": "^18.3.1",
+    "@vitejs/plugin-react": "^4.3.4",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-router-dom": "^6.21.1",
+    "config": "0.0.0"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "format": "prettier --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",
+    "publint": "publint",
+    "playwright": "playwright test ./test/functional",
+    "typecheck": "tsc -b"
+  }
+}

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,247 @@
+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 {};
+
+}