@discourse/types 0.0.1 → 0.0.2

package/external-types/ember-source/types/stable/@ember/-internals/glimmer/lib/components/abstract-input.d.ts

@@ -0,0 +1,37 @@
+declare module '@ember/-internals/glimmer/lib/components/abstract-input' {
+    import type { Reference } from "@glimmer/reference";
+    import type { EventListener } from "@ember/-internals/glimmer/lib/components/internal";
+    import InternalComponent from "@ember/-internals/glimmer/lib/components/internal";
+    type VirtualEventListener = (value: string, event: Event) => void;
+    export function valueFrom(reference?: Reference<unknown>): Value;
+    interface Value {
+        get(): unknown;
+        set(value: unknown): void;
+    }
+    export default abstract class AbstractInput extends InternalComponent {
+        validateArguments(): void;
+        private _value;
+        get value(): unknown;
+        set value(value: unknown);
+        valueDidChange(event: Event): void;
+        /**
+         * The `change` and `input` actions need to be overridden in the `Input`
+         * subclass. Unfortunately, some ember-source builds currently uses babel
+         * loose mode to transpile its classes. Having the `@action` decorator on the
+         * super class creates a getter on the prototype, and when the subclass
+         * overrides the method, the loose mode transpilation would emit something
+         * like `Subclass.prototype['change'] = function change() { ... }`, which
+         * fails because `prototype['change']` is getter-only/readonly. The correct
+         * solution is to use `Object.defineProperty(prototype, 'change', ...)` but
+         * that requires disabling loose mode. For now, the workaround is to add the
+         * decorator only on the subclass. This is more of a configuration issue on
+         * our own builds and doesn't really affect apps.
+         */
+        change(event: Event): void;
+        input(event: Event): void;
+        keyUp(event: KeyboardEvent): void;
+        protected listenerFor(name: string): EventListener;
+        protected isVirtualEventListener(name: string, _listener: Function): _listener is VirtualEventListener;
+    }
+    export {};
+}

package/external-types/ember-source/types/stable/@ember/-internals/glimmer/lib/components/input.d.ts

@@ -0,0 +1,8 @@
+declare module '@ember/-internals/glimmer/lib/components/input' {
+    import { type Opaque } from "@ember/-internals/utility-types";
+    import { type OpaqueInternalComponentConstructor } from "@ember/-internals/glimmer/lib/components/internal";
+    const Input: Input;
+    interface Input extends Opaque<"component:input">, OpaqueInternalComponentConstructor {
+    }
+    export default Input;
+}

package/external-types/ember-source/types/stable/@ember/-internals/glimmer/lib/components/internal.d.ts

@@ -0,0 +1,48 @@
+declare module '@ember/-internals/glimmer/lib/components/internal' {
+    import type { InternalOwner } from "@ember/-internals/owner";
+    import type { CapturedArguments, TemplateFactory } from "@glimmer/interfaces";
+    export type EventListener = (event: Event) => void;
+    export default class InternalComponent {
+        protected owner: InternalOwner;
+        protected readonly args: CapturedArguments;
+        protected readonly caller: unknown;
+        static toString(): string;
+        constructor(owner: InternalOwner, args: CapturedArguments, caller: unknown);
+        /**
+         * The default HTML id attribute. We don't really _need_ one, this is just
+         * added for compatibility as it's hard to tell if people rely on it being
+         * present, and it doens't really hurt.
+         *
+         * However, don't rely on this internally, like passing it to `getElementId`.
+         * This can be (and often is) overriden by passing an `id` attribute on the
+         * invocation, which shadows this default id via `...attributes`.
+         */
+        get id(): string;
+        /**
+         * The default HTML class attribute. Similar to the above, we don't _need_
+         * them, they are just added for compatibility as it's similarly hard to tell
+         * if people rely on it in their CSS etc, and it doens't really hurt.
+         */
+        get class(): string;
+        protected validateArguments(): void;
+        protected named(name: string): unknown;
+        protected positional(index: number): unknown;
+        protected listenerFor(name: string): EventListener;
+        protected isSupportedArgument(_name: string): boolean;
+        protected onUnsupportedArgument(_name: string): void;
+        toString(): string;
+    }
+    export interface InternalComponentConstructor<T extends InternalComponent = InternalComponent> {
+        new (owner: InternalOwner, args: CapturedArguments, caller: unknown): T;
+        prototype: T;
+        toString(): string;
+    }
+    const OPAQUE_INTERNAL_COMPONENT_CONSTRUCTOR: unique symbol;
+    export interface OpaqueInternalComponentConstructor {
+        create(): never;
+        toString(): string;
+        [OPAQUE_INTERNAL_COMPONENT_CONSTRUCTOR]: true;
+    }
+    export function opaquify(constructor: InternalComponentConstructor, template: TemplateFactory): OpaqueInternalComponentConstructor;
+    export {};
+}

package/external-types/ember-source/types/stable/@ember/-internals/glimmer/lib/components/link-to.d.ts

@@ -0,0 +1,8 @@
+declare module '@ember/-internals/glimmer/lib/components/link-to' {
+    import { type OpaqueInternalComponentConstructor } from "@ember/-internals/glimmer/lib/components/internal";
+    import { type Opaque } from "@ember/-internals/utility-types";
+    const LinkTo: LinkTo;
+    interface LinkTo extends Opaque<"component:link-to">, OpaqueInternalComponentConstructor {
+    }
+    export default LinkTo;
+}

package/external-types/ember-source/types/stable/@ember/-internals/glimmer/lib/components/textarea.d.ts

@@ -0,0 +1,11 @@
+declare module '@ember/-internals/glimmer/lib/components/textarea' {
+    /**
+    @module @ember/component
+    */
+    import { type Opaque } from "@ember/-internals/utility-types";
+    import { type OpaqueInternalComponentConstructor } from "@ember/-internals/glimmer/lib/components/internal";
+    const Textarea: Textarea;
+    interface Textarea extends Opaque<"component:textarea">, OpaqueInternalComponentConstructor {
+    }
+    export default Textarea;
+}

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

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/glimmer/lib/dom' {
+    export { DOMChanges, DOMTreeConstruction, clientBuilder, rehydrationBuilder, } from "@glimmer/runtime";
+    export { NodeDOMTreeConstruction, serializeBuilder } from "@glimmer/node";
+}

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

@@ -0,0 +1,11 @@
+declare module '@ember/-internals/glimmer/lib/environment' {
+    import type { InternalOwner } from "@ember/-internals/owner";
+    import type { EnvironmentDelegate } from "@glimmer/runtime";
+    export class EmberEnvironmentDelegate implements EnvironmentDelegate {
+        owner: InternalOwner;
+        isInteractive: boolean;
+        enableDebugTooling: boolean;
+        constructor(owner: InternalOwner, isInteractive: boolean);
+        onTransactionCommit(): void;
+    }
+}

package/external-types/ember-source/types/stable/@ember/-internals/glimmer/lib/glimmer-tracking-docs.d.ts

@@ -0,0 +1,245 @@
+declare module '@ember/-internals/glimmer/lib/glimmer-tracking-docs' {
+    /**
+      In order to tell Ember a value might change, we need to mark it as trackable.
+      Trackable values are values that:
+
+      - Can change over their component’s lifetime and
+      - Should cause Ember to rerender if and when they change
+
+      We can do this by marking the field with the `@tracked` decorator.
+
+      ### Caching a getter value
+
+      The `@cached` decorator can be used on getters in order to cache the
+      return value of the getter.
+
+      This method adds an extra overhead to each memoized getter, therefore caching
+      the values should not be the default strategy, but used in last resort.
+
+      @module @glimmer/tracking
+      @public
+    */
+    /**
+      Marks a property as tracked. By default, values that are rendered in Ember app
+      templates are _static_, meaning that updates to them won't cause the
+      application to rerender. Marking a property as tracked means that when that
+      property changes, any templates that used that property, directly or
+      indirectly, will rerender. For instance, consider this component:
+
+      ```handlebars
+      <div>Count: {{this.count}}</div>
+      <div>Times Ten: {{this.timesTen}}</div>
+      <div>
+        <button {{on "click" this.plusOne}}>
+          Plus One
+        </button>
+      </div>
+      ```
+
+      ```javascript
+      import Component from '@glimmer/component';
+      import { tracked } from '@glimmer/tracking';
+      import { action } from '@ember/object';
+
+      export default class CounterComponent extends Component {
+        @tracked count = 0;
+
+        get timesTen() {
+          return this.count * 10;
+        }
+
+        @action
+        plusOne() {
+          this.count += 1;
+        }
+      }
+      ```
+
+      Both the `{{this.count}}` and the `{{this.timesTen}}` properties in the
+      template will update whenever the button is clicked. Any tracked properties
+      that are used in any way to calculate a value that is used in the template
+      will cause a rerender when updated - this includes through method calls and
+      other means:
+
+      ```javascript
+      import Component from '@glimmer/component';
+      import { tracked } from '@glimmer/tracking';
+
+      class Entry {
+        @tracked name;
+        @tracked phoneNumber;
+
+        constructor(name, phoneNumber) {
+          this.name = name;
+          this.phoneNumber = phoneNumber;
+        }
+      }
+
+      export default class PhoneBookComponent extends Component {
+        entries = [
+          new Entry('Pizza Palace', 5551234),
+          new Entry('1st Street Cleaners', 5554321),
+          new Entry('Plants R Us', 5552468),
+        ];
+
+        // Any usage of this property will update whenever any of the names in the
+        // entries arrays are updated
+        get names() {
+          return this.entries.map(e => e.name);
+        }
+
+        // Any usage of this property will update whenever any of the numbers in the
+        // entries arrays are updated
+        get numbers() {
+          return this.getFormattedNumbers();
+        }
+
+        getFormattedNumbers() {
+          return this.entries
+            .map(e => e.phoneNumber)
+            .map(number => {
+              let numberString = '' + number;
+
+              return numberString.slice(0, 3) + '-' + numberString.slice(3);
+            });
+        }
+      }
+      ```
+
+      It's important to note that setting tracked properties will always trigger an
+      update, even if the property is set to the same value as it was before.
+
+      ```js
+      let entry = new Entry('Pizza Palace', 5551234);
+
+      // if entry was used when rendering, this would cause a rerender, even though
+      // the name is being set to the same value as it was before
+      entry.name = entry.name;
+      ```
+
+      `tracked` can also be used with the classic Ember object model in a similar
+      manner to classic computed properties:
+
+      ```javascript
+      import EmberObject from '@ember/object';
+      import { tracked } from '@glimmer/tracking';
+
+      const Entry = EmberObject.extend({
+        name: tracked(),
+        phoneNumber: tracked()
+      });
+      ```
+
+      Often this is unnecessary, but to ensure robust auto-tracking behavior it is
+      advisable to mark tracked state appropriately wherever possible.
+
+      This form of `tracked` also accepts an optional configuration object
+      containing either an initial `value` or an `initializer` function (but not
+      both).
+
+      ```javascript
+      import EmberObject from '@ember/object';
+      import { tracked } from '@glimmer/tracking';
+
+      const Entry = EmberObject.extend({
+        name: tracked({ value: 'Zoey' }),
+        favoriteSongs: tracked({
+          initializer: () => ['Raspberry Beret', 'Time After Time']
+        })
+      });
+      ```
+
+      @method tracked
+      @static
+      @for @glimmer/tracking
+      @public
+    */
+    /**
+      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 {};
+}

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

@@ -0,0 +1,180 @@
+declare module '@ember/-internals/glimmer/lib/helper' {
+    /**
+    @module @ember/component
+    */
+    import { FrameworkObject } from "@ember/object/-internals";
+    import type { Arguments, HelperManager } from "@glimmer/interfaces";
+    import type { DirtyableTag } from "@glimmer/validator";
+    export const RECOMPUTE_TAG: unique symbol;
+    type GetOr<T, K, Else> = K extends keyof T ? T[K] : Else;
+    type Args<S> = GetOr<S, "Args", {}>;
+    type DefaultPositional = unknown[];
+    type Positional<S> = GetOr<Args<S>, "Positional", DefaultPositional>;
+    type Named<S> = GetOr<Args<S>, "Named", object>;
+    type Return<S> = GetOr<S, "Return", unknown>;
+    export interface HelperFactory<T> {
+        isHelperFactory: true;
+        create(): T;
+    }
+    export interface HelperInstance<S> {
+        compute(positional: Positional<S>, named: Named<S>): Return<S>;
+        destroy(): void;
+        [RECOMPUTE_TAG]: DirtyableTag;
+    }
+    const IS_CLASSIC_HELPER: unique symbol;
+    export interface SimpleHelper<S> {
+        compute: (positional: Positional<S>, named: Named<S>) => Return<S>;
+    }
+    const SIGNATURE: unique symbol;
+    /**
+      Ember Helpers are functions that can compute values, and are used in templates.
+      For example, this code calls a helper named `format-currency`:
+
+      ```app/templates/application.hbs
+      <Cost @cents={{230}} />
+      ```
+
+      ```app/components/cost.hbs
+      <div>{{format-currency @cents currency="$"}}</div>
+      ```
+
+      Additionally a helper can be called as a nested helper.
+      In this example, we show the formatted currency value if the `showMoney`
+      named argument is truthy.
+
+      ```handlebars
+      {{if @showMoney (format-currency @cents currency="$")}}
+      ```
+
+      Helpers defined using a class must provide a `compute` function. For example:
+
+      ```app/helpers/format-currency.js
+      import Helper from '@ember/component/helper';
+
+      export default class extends Helper {
+        compute([cents], { currency }) {
+          return `${currency}${cents * 0.01}`;
+        }
+      }
+      ```
+
+      Each time the input to a helper changes, the `compute` function will be
+      called again.
+
+      As instances, these helpers also have access to the container and will accept
+      injected dependencies.
+
+      Additionally, class helpers can call `recompute` to force a new computation.
+
+      @class Helper
+      @extends CoreObject
+      @public
+      @since 1.13.0
+    */
+    export default interface Helper<S = unknown> {
+        /**
+          Override this function when writing a class-based helper.
+      
+          @method compute
+          @param {Array} positional The positional arguments to the helper
+          @param {Object} named The named arguments to the helper
+          @public
+          @since 1.13.0
+        */
+        compute(positional: Positional<S>, named: Named<S>): Return<S>;
+    }
+    export default class Helper<S = unknown> extends FrameworkObject {
+        static isHelperFactory: boolean;
+        static [IS_CLASSIC_HELPER]: boolean;
+        /** @deprecated */
+        static helper: typeof helper;
+        [RECOMPUTE_TAG]: DirtyableTag;
+        private [SIGNATURE];
+        init(properties: object | undefined): void;
+        /**
+          On a class-based helper, it may be useful to force a recomputation of that
+          helpers value. This is akin to `rerender` on a component.
+      
+          For example, this component will rerender when the `currentUser` on a
+          session service changes:
+      
+          ```app/helpers/current-user-email.js
+          import Helper from '@ember/component/helper'
+          import { service } from '@ember/service'
+          import { observer } from '@ember/object'
+      
+          export default Helper.extend({
+            session: service(),
+      
+            onNewUser: observer('session.currentUser', function() {
+              this.recompute();
+            }),
+      
+            compute() {
+              return this.get('session.currentUser.email');
+            }
+          });
+          ```
+      
+          @method recompute
+          @public
+          @since 1.13.0
+        */
+        recompute(): void;
+    }
+    export function isClassicHelper(obj: object): boolean;
+    export const CLASSIC_HELPER_MANAGER: import("@glimmer/interfaces").Helper<object> | import("@glimmer/manager").CustomHelperManager<object>;
+    class Wrapper<S = unknown> implements HelperFactory<SimpleHelper<S>> {
+        compute: (positional: Positional<S>, named: Named<S>) => Return<S>;
+        readonly isHelperFactory = true;
+        constructor(compute: (positional: Positional<S>, named: Named<S>) => Return<S>);
+        create(): SimpleHelper<S>;
+    }
+    class SimpleClassicHelperManager implements HelperManager<() => unknown> {
+        capabilities: import("@glimmer/interfaces").HelperCapabilities;
+        createHelper(definition: Wrapper, args: Arguments): () => unknown;
+        getValue(fn: () => unknown): unknown;
+        getDebugName(definition: Wrapper): string;
+    }
+    export const SIMPLE_CLASSIC_HELPER_MANAGER: SimpleClassicHelperManager;
+    /**
+     * The type of a function-based helper.
+     *
+     * @note This is *not* user-constructible: it is exported only so that the type
+     *   returned by the `helper` function can be named (and indeed can be exported
+     *   like `export default helper(...)` safely).
+     */
+    export type FunctionBasedHelper<S> = abstract new () => FunctionBasedHelperInstance<S>;
+    export abstract class FunctionBasedHelperInstance<S> extends Helper<S> {
+        protected abstract __concrete__: never;
+    }
+    /**
+      In many cases it is not necessary to use the full `Helper` class.
+      The `helper` method create pure-function helpers without instances.
+      For example:
+
+      ```app/helpers/format-currency.js
+      import { helper } from '@ember/component/helper';
+
+      export default helper(function([cents], {currency}) {
+        return `${currency}${cents * 0.01}`;
+      });
+      ```
+
+      @static
+      @param {Function} helper The helper function
+      @method helper
+      @for @ember/component/helper
+      @public
+      @since 1.13.0
+    */
+    export function helper<P extends DefaultPositional, N extends object, R = unknown>(helperFn: (positional: P, named: N) => R): FunctionBasedHelper<{
+        Args: {
+            Positional: P;
+            Named: N;
+        };
+        Return: R;
+    }>;
+    export function helper<S>(helperFn: (positional: Positional<S>, named: Named<S>) => Return<S>): FunctionBasedHelper<S>;
+    export {};
+}

package/external-types/ember-source/types/stable/@ember/-internals/glimmer/lib/helpers/-disallow-dynamic-resolution.d.ts

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/glimmer/lib/helpers/-disallow-dynamic-resolution' {
+    const _default: object;
+    export default _default;
+}

package/external-types/ember-source/types/stable/@ember/-internals/glimmer/lib/helpers/-in-element-null-check.d.ts

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/glimmer/lib/helpers/-in-element-null-check' {
+    const _default: object;
+    export default _default;
+}

package/external-types/ember-source/types/stable/@ember/-internals/glimmer/lib/helpers/-normalize-class.d.ts

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/glimmer/lib/helpers/-normalize-class' {
+    const _default: object;
+    export default _default;
+}

package/external-types/ember-source/types/stable/@ember/-internals/glimmer/lib/helpers/-resolve.d.ts

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/glimmer/lib/helpers/-resolve' {
+    const _default: object;
+    export default _default;
+}

package/external-types/ember-source/types/stable/@ember/-internals/glimmer/lib/helpers/-track-array.d.ts

@@ -0,0 +1,9 @@
+declare module '@ember/-internals/glimmer/lib/helpers/-track-array' {
+    /**
+      This reference is used to get the `[]` tag of iterables, so we can trigger
+      updates to `{{each}}` when it changes. It is put into place by a template
+      transform at build time, similar to the (-each-in) helper
+    */
+    const _default: object;
+    export default _default;
+}

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

@@ -0,0 +1,41 @@
+declare module '@ember/-internals/glimmer/lib/helpers/array' {
+    /**
+    @module ember
+    */
+    /**
+       Use the `{{array}}` helper to create an array to pass as an option to your
+       components.
+
+       ```handlebars
+       <MyComponent @people={{array
+         'Tom Dale'
+         'Yehuda Katz'
+         this.myOtherPerson}}
+       />
+       ```
+        or
+       ```handlebars
+       {{my-component people=(array
+         'Tom Dale'
+         'Yehuda Katz'
+         this.myOtherPerson)
+       }}
+       ```
+
+       Would result in an object such as:
+
+       ```js
+       ['Tom Dale', 'Yehuda Katz', this.get('myOtherPerson')]
+       ```
+
+       Where the 3rd item in the array is bound to updates of the `myOtherPerson` property.
+
+       @method array
+       @for @ember/helper
+       @param {Array} options
+       @return {Array} Array
+       @since 3.8.0
+       @public
+     */
+    export {};
+}