@discourse/types 0.0.1 → 2026.1.0-a5a0839

package/external-types/ember-source/types/stable/@ember/-internals/views/lib/system/event_dispatcher.d.ts

@@ -0,0 +1,117 @@
+declare module '@ember/-internals/views/lib/system/event_dispatcher' {
+    import EmberObject from "@ember/object";
+    /**
+      `Ember.EventDispatcher` handles delegating browser events to their
+      corresponding `Ember.Views.` For example, when you click on a view,
+      `Ember.EventDispatcher` ensures that that view's `mouseDown` method gets
+      called.
+
+      @class EventDispatcher
+      @namespace Ember
+      @private
+      @extends EmberObject
+    */
+    export default class EventDispatcher extends EmberObject {
+        /**
+          The set of events names (and associated handler function names) to be setup
+          and dispatched by the `EventDispatcher`. Modifications to this list can be done
+          at setup time, generally via the `Application.customEvents` hash.
+      
+          To add new events to be listened to:
+      
+          ```javascript
+          import Application from '@ember/application';
+      
+          let App = Application.create({
+            customEvents: {
+              paste: 'paste'
+            }
+          });
+          ```
+      
+          To prevent default events from being listened to:
+      
+          ```javascript
+          import Application from '@ember/application';
+      
+          let App = Application.create({
+            customEvents: {
+              mouseenter: null,
+              mouseleave: null
+            }
+          });
+          ```
+          @property events
+          @type Object
+          @private
+        */
+        events: Record<string, string>;
+        /**
+          The root DOM element to which event listeners should be attached. Event
+          listeners will be attached to the document unless this is overridden.
+      
+          Can be specified as a DOMElement or a selector string.
+      
+          The default body is a string since this may be evaluated before document.body
+          exists in the DOM.
+      
+          @private
+          @property rootElement
+          @type DOMElement
+          @default 'body'
+        */
+        rootElement: string | Element;
+        _eventHandlers: any;
+        _didSetup: boolean;
+        finalEventNameMapping: Record<string, string> | null;
+        _sanitizedRootElement: Element | null;
+        lazyEvents: Map<string, string | null>;
+        _reverseEventNameMapping: Record<string, string> | null;
+        /**
+          Sets up event listeners for standard browser events.
+      
+          This will be called after the browser sends a `DOMContentReady` event. By
+          default, it will set up all of the listeners on the document body. If you
+          would like to register the listeners on a different element, set the event
+          dispatcher's `root` property.
+      
+          @private
+          @method setup
+          @param addedEvents {Object}
+        */
+        setup(addedEvents: Record<string, string | null>, _rootElement: string | Element | null): void;
+        /**
+          Setup event listeners for the given browser event name
+      
+          @private
+          @method setupHandlerForBrowserEvent
+          @param event the name of the event in the browser
+        */
+        setupHandlerForBrowserEvent(event: string): void;
+        /**
+          Setup event listeners for the given Ember event name (camel case)
+      
+          @private
+          @method setupHandlerForEmberEvent
+          @param eventName
+        */
+        setupHandlerForEmberEvent(eventName: string): void;
+        /**
+          Registers an event listener on the rootElement. If the given event is
+          triggered, the provided event handler will be triggered on the target view.
+      
+          If the target view does not implement the event handler, or if the handler
+          returns `false`, the parent view will be called. The event will continue to
+          bubble to each successive parent view until it reaches the top.
+      
+          @private
+          @method setupHandler
+          @param {Element} rootElement
+          @param {String} event the name of the event in the browser
+          @param {String} eventName the name of the method to call on the view
+        */
+        setupHandler(rootElement: Element, event: string, eventName: string | null): void;
+        destroy(): any;
+        toString(): string;
+    }
+}

package/external-types/ember-source/types/stable/@ember/-internals/views/lib/system/utils.d.ts

@@ -0,0 +1,94 @@
+declare module '@ember/-internals/views/lib/system/utils' {
+    import type { View } from "@ember/-internals/glimmer/lib/renderer";
+    import type { InternalOwner } from "@ember/-internals/owner";
+    import type { Dict } from "@glimmer/interfaces";
+    import type { Nullable } from "@ember/-internals/utility-types";
+    /**
+    @module ember
+    */
+    export function isSimpleClick(event: Event): boolean;
+    export function constructStyleDeprecationMessage(affectedStyle: string): string;
+    /**
+      @private
+      @method getRootViews
+      @param {Object} owner
+    */
+    export function getRootViews(owner: InternalOwner): View[];
+    /**
+      @private
+      @method getViewId
+      @param {Ember.View} view
+     */
+    export function getViewId(view: View): string;
+    export function getElementView(element: Element): Nullable<View>;
+    /**
+      @private
+      @method getViewElement
+      @param {Ember.View} view
+     */
+    export function getViewElement(view: View): Nullable<Element>;
+    export function setElementView(element: Element, view: View): void;
+    export function setViewElement(view: View, element: Element): void;
+    export function clearElementView(element: Element): void;
+    export function clearViewElement(view: View): void;
+    /**
+      @private
+      @method getChildViews
+      @param {Ember.View} view
+    */
+    export function getChildViews(view: View): View[];
+    export function initChildViews(view: View): Set<string>;
+    export function addChildView(parent: View, child: View): void;
+    export function collectChildViews(view: View, registry: Dict<View>): View[];
+    /**
+      @private
+      @method getViewBounds
+      @param {Ember.View} view
+    */
+    export function getViewBounds(view: View): {
+        parentElement: import("@simple-dom/interface").SimpleElement;
+        firstNode: import("@simple-dom/interface").SimpleNode;
+        lastNode: import("@simple-dom/interface").SimpleNode;
+    };
+    /**
+      @private
+      @method getViewRange
+      @param {Ember.View} view
+    */
+    export function getViewRange(view: View): Range;
+    /**
+      `getViewClientRects` provides information about the position of the border
+      box edges of a view relative to the viewport.
+
+      It is only intended to be used by development tools like the Ember Inspector
+      and may not work on older browsers.
+
+      @private
+      @method getViewClientRects
+      @param {Ember.View} view
+    */
+    export function getViewClientRects(view: View): DOMRectList;
+    /**
+      `getViewBoundingClientRect` provides information about the position of the
+      bounding border box edges of a view relative to the viewport.
+
+      It is only intended to be used by development tools like the Ember Inspector
+      and may not work on older browsers.
+
+      @private
+      @method getViewBoundingClientRect
+      @param {Ember.View} view
+    */
+    export function getViewBoundingClientRect(view: View): ClientRect | DOMRect;
+    /**
+      Determines if the element matches the specified selector.
+
+      @private
+      @method matches
+      @param {DOMElement} el
+      @param {String} selector
+    */
+    export const elMatches: typeof Element.prototype.matches | undefined;
+    export function matches(el: Element, selector: string): boolean;
+    export function contains(a: Node, b: Node): boolean;
+}

package/external-types/ember-source/types/stable/@ember/-internals/views/lib/views/core_view.d.ts

@@ -0,0 +1,59 @@
+declare module '@ember/-internals/views/lib/views/core_view' {
+    import type { Renderer, View } from "@ember/-internals/glimmer/lib/renderer";
+    import { ActionHandler } from "@ember/-internals/runtime";
+    import Evented from "@ember/object/evented";
+    import type { ViewState } from "@ember/-internals/views/lib/views/states";
+    import states from "@ember/-internals/views/lib/views/states";
+    /**
+      `Ember.CoreView` is an abstract class that exists to give view-like behavior
+      to both Ember's main view class `Component` and other classes that don't need
+      the full functionality of `Component`.
+
+      Unless you have specific needs for `CoreView`, you will use `Component`
+      in your applications.
+
+      @class CoreView
+      @namespace Ember
+      @extends EmberObject
+      @deprecated Use `Component` instead.
+      @uses Evented
+      @uses Ember.ActionHandler
+      @private
+    */
+    interface CoreView extends Evented, ActionHandler, View {
+    }
+    const CoreView_base: Readonly<typeof import("@ember/object").default> & (new (owner?: import("@ember/owner").default | undefined) => import("@ember/object").default) & import("@ember/object/mixin").default;
+    class CoreView extends CoreView_base {
+        isView: boolean;
+        _states: typeof states;
+        _state: keyof typeof states;
+        _currentState: ViewState;
+        _superTrigger?: Evented["trigger"];
+        _superHas?: Evented["has"];
+        /**
+          If the view is currently inserted into the DOM of a parent view, this
+          property will point to the parent of the view.
+      
+          @property parentView
+          @type Ember.View
+          @default null
+          @private
+        */
+        parentView: View | null;
+        init(properties: object | undefined): void;
+        renderer: Renderer;
+        instrumentDetails(hash: Record<string, unknown>): Record<string, unknown>;
+        /**
+          Override the default event firing from `Evented` to
+          also call methods with the given name.
+      
+          @method trigger
+          @param name {String}
+          @private
+        */
+        _trigger(name: string, ...args: any[]): any;
+        _has(name: string): boolean;
+        static isViewFactory: boolean;
+    }
+    export default CoreView;
+}

package/external-types/ember-source/types/stable/@ember/-internals/views/lib/views/states.d.ts

@@ -0,0 +1,18 @@
+declare module '@ember/-internals/views/lib/views/states' {
+    import type Component from "@ember/component";
+    export interface ViewState {
+        enter?(view: Component): void;
+        exit?(view: Component): void;
+        appendChild(): void;
+        handleEvent(view: Component, eventName: string, event: Event): boolean;
+        rerender(view: Component): void;
+        destroy(view: Component): void;
+    }
+    const states: Readonly<{
+        preRender: Readonly<ViewState>;
+        inDOM: Readonly<ViewState>;
+        hasElement: Readonly<ViewState>;
+        destroying: Readonly<ViewState>;
+    }>;
+    export default states;
+}