@discourse/types 0.0.1 → 2026.1.0-61b723a

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

@@ -0,0 +1,174 @@
+declare module '@ember/-internals/meta/lib/meta' {
+    import type { ComputedProperty } from "@ember/-internals/metal";
+    import type { Revision, UpdatableTag } from "@glimmer/validator";
+    type ObjMap<T> = {
+        [key: string]: T;
+    };
+    export interface MetaCounters {
+        peekCalls: number;
+        peekPrototypeWalks: number;
+        setCalls: number;
+        deleteCalls: number;
+        metaCalls: number;
+        metaInstantiated: number;
+        matchingListenersCalls: number;
+        observerEventsCalls: number;
+        addToListenersCalls: number;
+        removeFromListenersCalls: number;
+        removeAllListenersCalls: number;
+        listenersInherited: number;
+        listenersFlattened: number;
+        parentListenersUsed: number;
+        flattenedListenersCalls: number;
+        reopensAfterFlatten: number;
+        readableLazyChainsCalls: number;
+        writableLazyChainsCalls: number;
+    }
+    let counters: MetaCounters | undefined;
+    /**
+    @module ember
+    */
+    export const UNDEFINED: symbol;
+    const enum ListenerKind {
+        ADD = 0,
+        ONCE = 1,
+        REMOVE = 2
+    }
+    interface StringListener {
+        event: string;
+        target: null;
+        method: string;
+        kind: ListenerKind.ADD | ListenerKind.ONCE | ListenerKind.REMOVE;
+        sync: boolean;
+    }
+    interface FunctionListener {
+        event: string;
+        target: object | null;
+        method: Function;
+        kind: ListenerKind.ADD | ListenerKind.ONCE | ListenerKind.REMOVE;
+        sync: boolean;
+    }
+    type Listener = StringListener | FunctionListener;
+    export class Meta {
+        /** @internal */
+        _descriptors: Map<string, any> | undefined;
+        /** @internal */
+        _mixins: any | undefined;
+        /** @internal */
+        _isInit: boolean;
+        /** @internal */
+        _lazyChains: ObjMap<[UpdatableTag, unknown][]> | undefined;
+        /** @internal */
+        _values: ObjMap<unknown> | undefined;
+        /** @internal */
+        _revisions: ObjMap<Revision> | undefined;
+        /** @internal */
+        source: object;
+        /** @internal */
+        proto: object | undefined;
+        /** @internal */
+        _parent: Meta | undefined | null;
+        /** @internal */
+        _listeners: Listener[] | undefined;
+        /** @internal */
+        _listenersVersion: number;
+        /** @internal */
+        _inheritedEnd: number;
+        /** @internal */
+        _flattenedVersion: number;
+        /** @internal */
+        constructor(obj: object);
+        /** @internal */
+        get parent(): Meta | null;
+        setInitializing(): void;
+        /** @internal */
+        unsetInitializing(): void;
+        /** @internal */
+        isInitializing(): boolean;
+        /** @internal */
+        isPrototypeMeta(obj: object): boolean;
+        /** @internal */
+        _getOrCreateOwnMap(key: "_values" | "_revisions" | "_lazyChains"): any;
+        /** @internal */
+        _getOrCreateOwnSet(key: "_mixins"): any;
+        /** @internal */
+        _findInheritedMap(key: keyof Meta, subkey: string): any | undefined;
+        /** @internal */
+        _hasInInheritedSet(key: keyof Meta, value: any): boolean;
+        /** @internal */
+        valueFor(key: string): unknown;
+        /** @internal */
+        setValueFor(key: string, value: unknown): void;
+        /** @internal */
+        revisionFor(key: string): Revision | undefined;
+        /** @internal */
+        setRevisionFor(key: string, revision: Revision | undefined): void;
+        /** @internal */
+        writableLazyChainsFor(key: string): [UpdatableTag, unknown][];
+        /** @internal */
+        readableLazyChainsFor(key: string): [UpdatableTag, unknown][] | undefined;
+        /** @internal */
+        addMixin(mixin: any): void;
+        /** @internal */
+        hasMixin(mixin: any): boolean;
+        /** @internal */
+        forEachMixins(fn: Function): void;
+        /** @internal */
+        writeDescriptors(subkey: string, value: any): void;
+        /** @internal */
+        peekDescriptors(subkey: string): any;
+        /** @internal */
+        removeDescriptors(subkey: string): void;
+        /** @internal */
+        forEachDescriptors(fn: (key: string, value: ComputedProperty) => void): void;
+        /** @internal */
+        addToListeners(eventName: string, target: object | null, method: Function | PropertyKey, once: boolean, sync: boolean): void;
+        /** @internal */
+        removeFromListeners(eventName: string, target: object | null, method: Function | string): void;
+        private pushListener;
+        private writableListeners;
+        /**
+          Flattening is based on a global revision counter. If the revision has
+          bumped it means that somewhere in a class inheritance chain something has
+          changed, so we need to reflatten everything. This can only happen if:
+      
+          1. A meta has been flattened (listener has been called)
+          2. The meta is a prototype meta with children who have inherited its
+             listeners
+          3. A new listener is subsequently added to the meta (e.g. via `.reopen()`)
+      
+          This is a very rare occurrence, so while the counter is global it shouldn't
+          be updated very often in practice.
+        */
+        private flattenedListeners;
+        /** @internal */
+        matchingListeners(eventName: string): (string | boolean | object | null)[] | undefined;
+        /** @internal */
+        observerEvents(): any[] | undefined;
+    }
+    export function setMeta(obj: object, meta: Meta): void;
+    export function peekMeta(obj: object): Meta | null;
+    /**
+      Retrieves the meta hash for an object. If `writable` is true ensures the
+      hash is writable for this object as well.
+
+      The meta object contains information about computed property descriptors as
+      well as any watched properties and other information. You generally will
+      not access this information directly but instead work with higher level
+      methods that manipulate this hash indirectly.
+
+      @method meta
+      @for Ember
+      @private
+
+      @param {Object} obj The object to retrieve meta for
+      @param {Boolean} [writable=true] Pass `false` if you do not intend to modify
+        the meta hash, allowing the method to avoid making an unnecessary copy.
+      @return {Object} the meta hash for an object
+    */
+    export const meta: {
+        (obj: object): Meta;
+        _counters?: MetaCounters;
+    };
+    export { counters };
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/index.d.ts

@@ -0,0 +1,26 @@
+declare module '@ember/-internals/metal' {
+    export { default as computed, autoComputed, isComputed, ComputedProperty, type ComputedDecorator, type ComputedPropertyGetter, type ComputedPropertyObj, type ComputedPropertySetter, type ComputedPropertyCallback, } from "@ember/-internals/metal/lib/computed";
+    export { getCachedValueFor } from "@ember/-internals/metal/lib/computed_cache";
+    export { default as alias } from "@ember/-internals/metal/lib/alias";
+    export { deprecateProperty } from "@ember/-internals/metal/lib/deprecate_property";
+    export { PROXY_CONTENT, _getPath, get, _getProp, type HasUnknownProperty, hasUnknownProperty, } from "@ember/-internals/metal/lib/property_get";
+    export { set, _setProp, trySet } from "@ember/-internals/metal/lib/property_set";
+    export { objectAt, replace, replaceInNativeArray, addArrayObserver, removeArrayObserver, } from "@ember/-internals/metal/lib/array";
+    export { arrayContentWillChange, arrayContentDidChange } from "@ember/-internals/metal/lib/array_events";
+    export { eachProxyArrayWillChange, eachProxyArrayDidChange } from "@ember/-internals/metal/lib/each_proxy_events";
+    export { addListener, hasListeners, on, removeListener, sendEvent } from "@ember/-internals/metal/lib/events";
+    export { beginPropertyChanges, changeProperties, endPropertyChanges, notifyPropertyChange, type PropertyDidChange, PROPERTY_DID_CHANGE, } from "@ember/-internals/metal/lib/property_events";
+    export { defineProperty, defineDecorator, defineValue } from "@ember/-internals/metal/lib/properties";
+    export { type ExtendedMethodDecorator, type DecoratorPropertyDescriptor, ComputedDescriptor, type ElementDescriptor, isElementDescriptor, nativeDescDecorator, descriptorForDecorator, descriptorForProperty, isClassicDecorator, setClassicDecorator, makeComputedDecorator, } from "@ember/-internals/metal/lib/decorator";
+    export { default as libraries, Libraries } from "@ember/-internals/metal/lib/libraries";
+    export { default as getProperties } from "@ember/-internals/metal/lib/get_properties";
+    export { default as setProperties } from "@ember/-internals/metal/lib/set_properties";
+    export { default as expandProperties } from "@ember/-internals/metal/lib/expand_properties";
+    export { ASYNC_OBSERVERS, SYNC_OBSERVERS, addObserver, activateObserver, removeObserver, flushAsyncObservers, revalidateObservers, } from "@ember/-internals/metal/lib/observer";
+    export { default as inject, DEBUG_INJECTION_FUNCTIONS } from "@ember/-internals/metal/lib/injected_property";
+    export { tagForProperty, tagForObject, markObjectAsDirty } from "@ember/-internals/metal/lib/tags";
+    export { tracked, TrackedDescriptor } from "@ember/-internals/metal/lib/tracked";
+    export { cached } from "@ember/-internals/metal/lib/cached";
+    export { createCache, getValue, isConst } from "@ember/-internals/metal/lib/cache";
+    export { NAMESPACES, NAMESPACES_BY_ID, addNamespace, findNamespace, findNamespaces, processNamespace, processAllNamespaces, removeNamespace, isSearchDisabled as isNamespaceSearchDisabled, setSearchDisabled as setNamespaceSearchDisabled, setUnprocessedMixins, } from "@ember/-internals/metal/lib/namespace_search";
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/alias.d.ts

@@ -0,0 +1,22 @@
+declare module '@ember/-internals/metal/lib/alias' {
+    import type { Meta } from "@ember/-internals/meta";
+    import type { ExtendedMethodDecorator } from "@ember/-internals/metal/lib/decorator";
+    import { ComputedDescriptor } from "@ember/-internals/metal/lib/decorator";
+    export type AliasDecorator = ExtendedMethodDecorator & PropertyDecorator & AliasDecoratorImpl;
+    export default function alias(altKey: string): AliasDecorator;
+    class AliasDecoratorImpl extends Function {
+        readOnly(this: ExtendedMethodDecorator): ExtendedMethodDecorator;
+        oneWay(this: ExtendedMethodDecorator): ExtendedMethodDecorator;
+        meta(this: ExtendedMethodDecorator, meta?: any): any;
+    }
+    export class AliasedProperty extends ComputedDescriptor {
+        readonly altKey: string;
+        constructor(altKey: string);
+        setup(obj: object, keyName: string, propertyDesc: PropertyDescriptor, meta: Meta): void;
+        get(obj: object, keyName: string): any;
+        set(obj: object, _keyName: string, value: any): any;
+        readOnly(): void;
+        oneWay(): void;
+    }
+    export {};
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/array.d.ts

@@ -0,0 +1,30 @@
+declare module '@ember/-internals/metal/lib/array' {
+    import type EmberArray from "@ember/array";
+    import type MutableArray from "@ember/array/mutable";
+    type ObservedArray<T> = (T[] | EmberArray<T>) & ObservedObject;
+    interface ObservedObject {
+        _revalidate?: () => void;
+    }
+    export { objectAt } from "@ember/-internals/metal/lib/object-at";
+    export function replace<T>(
+        array: T[] | MutableArray<T>,
+        start: number,
+        deleteCount: number,
+        items?: readonly T[]
+    ): void;
+    export function replaceInNativeArray<T>(array: T[], start: number, deleteCount: number, items: ReadonlyArray<T>): void;
+    interface ArrayObserverOptions {
+        willChange: string;
+        didChange: string;
+    }
+    export function addArrayObserver<T>(
+        array: EmberArray<T>,
+        target: object | Function | null,
+        opts: ArrayObserverOptions
+    ): ObservedArray<T>;
+    export function removeArrayObserver<T>(
+        array: T[] | EmberArray<T>,
+        target: object | Function | null,
+        opts: ArrayObserverOptions
+    ): ObservedArray<T>;
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/array_events.d.ts

@@ -0,0 +1,12 @@
+declare module '@ember/-internals/metal/lib/array_events' {
+    export function arrayContentWillChange<T extends object>(array: T, startIdx: number, removeAmt: number, addAmt: number): T;
+    export function arrayContentDidChange<T extends {
+        length: number;
+    }>(
+        array: T,
+        startIdx: number,
+        removeAmt: number,
+        addAmt: number,
+        notify?: boolean
+    ): T;
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/cache.d.ts

@@ -0,0 +1,121 @@
+declare module '@ember/-internals/metal/lib/cache' {
+    export { createCache, getValue, isConst } from "@glimmer/validator";
+    /**
+      Ember uses caching based on trackable values to avoid updating large portions
+      of the application. This caching is exposed via a cache primitive that can be
+      used to cache a specific computation, so that it will not update and will
+      return the cached value until a tracked value used in its computation has
+      updated.
+
+      @module @glimmer/tracking/primitives/cache
+      @public
+    */
+    /**
+      Receives a function, and returns a wrapped version of it that memoizes based on
+      _autotracking_. The function will only rerun whenever any tracked values used
+      within it have changed. Otherwise, it will return the previous value.
+
+      ```js
+      import { tracked } from '@glimmer/tracking';
+      import { createCache, getValue } from '@glimmer/tracking/primitives/cache';
+
+      class State {
+        @tracked value;
+      }
+
+      let state = new State();
+      let computeCount = 0;
+
+      let counter = createCache(() => {
+        // consume the state. Now, `counter` will
+        // only rerun if `state.value` changes.
+        state.value;
+
+        return ++computeCount;
+      });
+
+      getValue(counter); // 1
+
+      // returns the same value because no tracked state has changed
+      getValue(counter); // 1
+
+      state.value = 'foo';
+
+      // reruns because a tracked value used in the function has changed,
+      // incermenting the counter
+      getValue(counter); // 2
+      ```
+
+      @method createCache
+      @static
+      @for @glimmer/tracking/primitives/cache
+      @public
+    */
+    /**
+      Gets the value of a cache created with `createCache`.
+
+      ```js
+      import { tracked } from '@glimmer/tracking';
+      import { createCache, getValue } from '@glimmer/tracking/primitives/cache';
+
+      let computeCount = 0;
+
+      let counter = createCache(() => {
+        return ++computeCount;
+      });
+
+      getValue(counter); // 1
+      ```
+
+      @method getValue
+      @static
+      @for @glimmer/tracking/primitives/cache
+      @public
+    */
+    /**
+      Can be used to check if a memoized function is _constant_. If no tracked state
+      was used while running a memoized function, it will never rerun, because nothing
+      can invalidate its result. `isConst` can be used to determine if a memoized
+      function is constant or not, in order to optimize code surrounding that
+      function.
+
+      ```js
+      import { tracked } from '@glimmer/tracking';
+      import { createCache, getValue, isConst } from '@glimmer/tracking/primitives/cache';
+
+      class State {
+        @tracked value;
+      }
+
+      let state = new State();
+      let computeCount = 0;
+
+      let counter = createCache(() => {
+        // consume the state
+        state.value;
+
+        return computeCount++;
+      });
+
+      let constCounter = createCache(() => {
+        return computeCount++;
+      });
+
+      getValue(counter);
+      getValue(constCounter);
+
+      isConst(counter); // false
+      isConst(constCounter); // true
+      ```
+
+      If called on a cache that hasn't been accessed yet, it will throw an
+      error. This is because there's no way to know if the function will be constant
+      or not yet, and so this helps prevent missing an optimization opportunity on
+      accident.
+
+      @method isConst
+      @static
+      @for @glimmer/tracking/primitives/cache
+      @public
+    */
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/cached.d.ts

@@ -0,0 +1,92 @@
+declare module '@ember/-internals/metal/lib/cached' {
+    /**
+     * @decorator
+     *
+      Gives the getter a caching behavior. The return value of the getter
+      will be cached until any of the properties it is entangled with
+      are invalidated. This is useful when a getter is expensive and
+      used very often.
+
+      For instance, in this `GuestList` class, we have the `sortedGuests`
+      getter that sorts the guests alphabetically:
+
+      ```javascript
+        import { tracked } from '@glimmer/tracking';
+
+        class GuestList {
+          @tracked guests = ['Zoey', 'Tomster'];
+
+          get sortedGuests() {
+            return this.guests.slice().sort()
+          }
+        }
+      ```
+
+      Every time `sortedGuests` is accessed, a new array will be created and sorted,
+      because JavaScript getters do not cache by default. When the guest list
+      is small, like the one in the example, this is not a problem. However, if
+      the guest list were to grow very large, it would mean that we would be doing
+      a large amount of work each time we accessed `sortedGuests`. With `@cached`,
+      we can cache the value instead:
+
+      ```javascript
+        import { tracked, cached } from '@glimmer/tracking';
+
+        class GuestList {
+          @tracked guests = ['Zoey', 'Tomster'];
+
+          @cached
+          get sortedGuests() {
+            return this.guests.slice().sort()
+          }
+        }
+      ```
+
+      Now the `sortedGuests` getter will be cached based on autotracking.
+      It will only rerun and create a new sorted array when the guests tracked
+      property is updated.
+
+
+      ### Tradeoffs
+
+      Overuse is discouraged.
+
+      In general, you should avoid using `@cached` unless you have confirmed that
+      the getter you are decorating is computationally expensive, since `@cached`
+      adds a small amount of overhead to the getter.
+      While the individual costs are small, a systematic use of the `@cached`
+      decorator can add up to a large impact overall in your app.
+      Many getters and tracked properties are only accessed once during rendering,
+      and then never rerendered, so adding `@cached` when unnecessary can
+      negatively impact performance.
+
+      Also, `@cached` may rerun even if the values themselves have not changed,
+      since tracked properties will always invalidate.
+      For example updating an integer value from `5` to an other `5` will trigger
+      a rerun of the cached properties building from this integer.
+
+      Avoiding a cache invalidation in this case is not something that can
+      be achieved on the `@cached` decorator itself, but rather when updating
+      the underlying tracked values, by applying some diff checking mechanisms:
+
+      ```javascript
+      if (nextValue !== this.trackedProp) {
+        this.trackedProp = nextValue;
+      }
+      ```
+
+      Here equal values won't update the property, therefore not triggering
+      the subsequent cache invalidations of the `@cached` properties who were
+      using this `trackedProp`.
+
+      Remember that setting tracked data should only be done during initialization,
+      or as the result of a user action. Setting tracked data during render
+      (such as in a getter), is not supported.
+
+      @method cached
+      @static
+      @for @glimmer/tracking
+      @public
+     */
+    export const cached: MethodDecorator;
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/chain-tags.d.ts

@@ -0,0 +1,8 @@
+declare module '@ember/-internals/metal/lib/chain-tags' {
+    import type { Meta } from "@ember/-internals/meta";
+    import type { Tag, TagMeta } from "@glimmer/validator";
+    export const CHAIN_PASS_THROUGH: WeakSet<object>;
+    export function finishLazyChains(meta: Meta, key: string, value: any): void;
+    export function getChainTagsForKeys(obj: object, keys: string[], tagMeta: TagMeta, meta: Meta | null): Tag;
+    export function getChainTagsForKey(obj: object, key: string, tagMeta: TagMeta, meta: Meta | null): Tag;
+}

package/external-types/ember-source/types/stable/@ember/-internals/metal/lib/change_event.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/-internals/metal/lib/change_event' {
+    export default function changeEvent(keyName: string): string;
+}