@discourse/types 0.0.1 → 2026.1.0-a5a0839

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

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

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

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

package/external-types/@ember__test-helpers/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "@ember/test-helpers",
+  "version": "5.4.1",
+  "description": "Helpers for testing Ember.js applications",
+  "keywords": [
+    "ember-addon"
+  ],
+  "homepage": "https://github.com/emberjs/ember-test-helpers#readme",
+  "bugs": {
+    "url": "https://github.com/emberjs/ember-test-helpers/issues"
+  },
+  "repository": "https://github.com/emberjs/ember-test-helpers",
+  "license": "(MIT OR Apache-2.0)",
+  "author": "",
+  "exports": {
+    ".": {
+      "types": "./declarations/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./declarations/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./addon-main.js": "./addon-main.cjs"
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "declarations/*"
+      ]
+    }
+  },
+  "files": [
+    "addon-main.cjs",
+    "declarations",
+    "dist"
+  ],
+  "dependencies": {
+    "@ember/test-waiters": "^3.1.0 || ^4.0.0",
+    "@embroider/addon-shim": "^1.10.2",
+    "@embroider/macros": "^1.16.5",
+    "@simple-dom/interface": "^1.4.0",
+    "decorator-transforms": "^2.0.0",
+    "dom-element-descriptors": "^0.5.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.2",
+    "@babel/plugin-transform-typescript": "^7.25.2",
+    "@babel/runtime": "^7.24.4",
+    "@embroider/addon-dev": "^5.0.0",
+    "@glint/template": "^1.4.0",
+    "@rollup/plugin-babel": "^6.0.4",
+    "@tsconfig/ember": "^3.0.6",
+    "@types/rsvp": "^4.0.9",
+    "@typescript-eslint/eslint-plugin": "^8.2.0",
+    "@typescript-eslint/parser": "^8.2.0",
+    "babel-plugin-ember-template-compilation": "^2.2.5",
+    "concurrently": "^8.2.2",
+    "documentation": "^14.0.3",
+    "ember-source": "^5.11.0",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-ember": "^12.2.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-n": "^17.10.2",
+    "eslint-plugin-prettier": "^5.1.3",
+    "execa": "^9.3.1",
+    "fix-bad-declaration-output": "^1.1.4",
+    "prettier": "^3.2.5",
+    "prettier-plugin-ember-template-tag": "^2.0.2",
+    "rollup": "^4.21.0",
+    "rollup-plugin-copy": "^3.5.0",
+    "typescript": "^5.4.5"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "ember": {
+    "edition": "octane"
+  },
+  "ember-addon": {
+    "version": 2,
+    "type": "addon",
+    "main": "addon-main.cjs",
+    "app-js": {},
+    "externals": [
+      "@glimmer/manager",
+      "@ember/-internals",
+      "@ember/renderer",
+      "ember-testing"
+    ]
+  },
+  "volta": {
+    "extends": "../package.json"
+  },
+  "scripts": {
+    "build": "rollup --config",
+    "build:docs": "pnpm build && documentation build --document-exported \"./dist/index.js\" --config documentation.yml --markdown-toc-max-depth 3 -f md -o ../API.md",
+    "lint": "concurrently 'pnpm:lint:*(!fix)' --names 'lint:'",
+    "lint:fix": "concurrently 'pnpm:lint:*:fix' --names 'fix:'",
+    "lint:js": "eslint . --cache",
+    "lint:js:fix": "eslint . --fix",
+    "lint:types": "tsc --noEmit --emitDeclarationOnly false",
+    "start": "rollup --config --watch --no-watch.clearScreen",
+    "test": "echo 'A v2 addon does not have tests, run tests in test-app'"
+  }
+}

package/external-types/@floating-ui__dom/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2021-present Floating UI contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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

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