@discourse/types 0.0.1 → 0.0.2

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

@@ -0,0 +1,182 @@
+declare module '@ember/-internals/glimmer/lib/helpers/if-unless' {
+    /**
+    @module ember
+    */
+    /**
+      The `if` helper allows you to conditionally render one of two branches,
+      depending on the "truthiness" of a property.
+      For example the following values are all falsey: `false`, `undefined`, `null`, `""`, `0`, `NaN` or an empty array.
+
+      This helper has two forms, block and inline.
+
+      ## Block form
+
+      You can use the block form of `if` to conditionally render a section of the template.
+
+      To use it, pass the conditional value to the `if` helper,
+      using the block form to wrap the section of template you want to conditionally render.
+      Like so:
+
+      ```app/templates/application.hbs
+      <Weather />
+      ```
+
+      ```app/components/weather.hbs
+      {{! will not render because greeting is undefined}}
+      {{#if @isRaining}}
+        Yes, grab an umbrella!
+      {{/if}}
+      ```
+
+      You can also define what to show if the property is falsey by using
+      the `else` helper.
+
+      ```app/components/weather.hbs
+      {{#if @isRaining}}
+        Yes, grab an umbrella!
+      {{else}}
+        No, it's lovely outside!
+      {{/if}}
+      ```
+
+      You are also able to combine `else` and `if` helpers to create more complex
+      conditional logic.
+
+      For the following template:
+
+       ```app/components/weather.hbs
+      {{#if @isRaining}}
+        Yes, grab an umbrella!
+      {{else if @isCold}}
+        Grab a coat, it's chilly!
+      {{else}}
+        No, it's lovely outside!
+      {{/if}}
+      ```
+
+      If you call it by saying `isCold` is true:
+
+      ```app/templates/application.hbs
+      <Weather @isCold={{true}} />
+      ```
+
+      Then `Grab a coat, it's chilly!` will be rendered.
+
+      ## Inline form
+
+      The inline `if` helper conditionally renders a single property or string.
+
+      In this form, the `if` helper receives three arguments, the conditional value,
+      the value to render when truthy, and the value to render when falsey.
+
+      For example, if `useLongGreeting` is truthy, the following:
+
+      ```app/templates/application.hbs
+      <Greeting @useLongGreeting={{true}} />
+      ```
+
+      ```app/components/greeting.hbs
+      {{if @useLongGreeting "Hello" "Hi"}} Alex
+      ```
+
+      Will render:
+
+      ```html
+      Hello Alex
+      ```
+
+      One detail to keep in mind is that both branches of the `if` helper will be evaluated,
+      so if you have `{{if condition "foo" (expensive-operation "bar")`,
+      `expensive-operation` will always calculate.
+
+      @method if
+      @for Ember.Templates.helpers
+      @public
+    */
+    /**
+      The `unless` helper is the inverse of the `if` helper. It displays if a value
+      is falsey ("not true" or "is false"). Example values that will display with
+      `unless`: `false`, `undefined`, `null`, `""`, `0`, `NaN` or an empty array.
+
+      ## Inline form
+
+      The inline `unless` helper conditionally renders a single property or string.
+      This helper acts like a ternary operator. If the first property is falsy,
+      the second argument will be displayed, otherwise, the third argument will be
+      displayed
+
+      For example, if you pass a falsey `useLongGreeting` to the `Greeting` component:
+
+      ```app/templates/application.hbs
+      <Greeting @useLongGreeting={{false}} />
+      ```
+
+      ```app/components/greeting.hbs
+      {{unless @useLongGreeting "Hi" "Hello"}} Ben
+      ```
+
+      Then it will display:
+
+      ```html
+      Hi Ben
+      ```
+
+      ## Block form
+
+      Like the `if` helper, the `unless` helper also has a block form.
+
+      The following will not render anything:
+
+      ```app/templates/application.hbs
+      <Greeting />
+      ```
+
+      ```app/components/greeting.hbs
+      {{#unless @greeting}}
+        No greeting was found. Why not set one?
+      {{/unless}}
+      ```
+
+      You can also use an `else` helper with the `unless` block. The
+      `else` will display if the value is truthy.
+
+      If you have the following component:
+
+      ```app/components/logged-in.hbs
+      {{#unless @userData}}
+        Please login.
+      {{else}}
+        Welcome back!
+      {{/unless}}
+      ```
+
+      Calling it with a truthy `userData`:
+
+      ```app/templates/application.hbs
+      <LoggedIn @userData={{hash username="Zoey"}} />
+      ```
+
+      Will render:
+
+      ```html
+      Welcome back!
+      ```
+
+      and calling it with a falsey `userData`:
+
+      ```app/templates/application.hbs
+      <LoggedIn @userData={{false}} />
+      ```
+
+      Will render:
+
+      ```html
+      Please login.
+      ```
+
+      @method unless
+      @for Ember.Templates.helpers
+      @public
+    */
+    export {};
+}

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

@@ -0,0 +1,5 @@
+declare module '@ember/-internals/glimmer/lib/helpers/internal-helper' {
+    import type { InternalOwner } from "@ember/-internals/owner";
+    import type { Helper, HelperDefinitionState } from "@glimmer/interfaces";
+    export function internalHelper(helper: Helper<InternalOwner>): HelperDefinitionState;
+}

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

@@ -0,0 +1,19 @@
+declare module '@ember/-internals/glimmer/lib/helpers/log' {
+    /**
+    @module ember
+    */
+    /**
+      `log` allows you to output the value of variables in the current rendering
+      context. `log` also accepts primitive types such as strings or numbers.
+
+      ```handlebars
+      {{log "myVariable:" myVariable }}
+      ```
+
+      @method log
+      @for Ember.Templates.helpers
+      @param {Array} params
+      @public
+    */
+    export {};
+}

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

@@ -0,0 +1,42 @@
+declare module '@ember/-internals/glimmer/lib/helpers/modifier' {
+    /**
+     @module ember
+     */
+    /**
+     Use the `{{modifier}}` helper to create contextual modifier so
+     that it can be passed around as first-class values in templates.
+
+     ```handlebars
+     {{#let (modifier "click-outside" click=this.submit) as |on-click-outside|}}
+
+       {{!-- this is equivalent to `<MyComponent {{click-outside click=this.submit}} />` --}}
+       <MyComponent {{on-click-outside}} />
+
+       {{!-- this will pass the modifier itself into the component, instead of invoking it now --}}
+       <MyComponent @modifier={{modifier on-click-outside "extra" "args"}} />
+
+       {{!-- this will yield the modifier itself ("contextual modifier"), instead of invoking it now --}}
+       {{yield on-click-outside}}
+     {{/let}}
+     ```
+
+     ### Arguments
+
+     The `{{modifier}}` helper works similarly to the [`{{component}}`](./component?anchor=component) and
+     [`{{helper}}`](./helper?anchor=helper) helper:
+
+     * When passed a string (e.g. `(modifier "foo")`) as the first argument,
+       it will produce an opaque, internal "modifier definition" object
+       that can be passed around and invoked elsewhere.
+
+     * Any additional positional and/or named arguments (a.k.a. params and hash)
+       will be stored ("curried") inside the definition object, such that, when invoked,
+       these arguments will be passed along to the referenced modifier.
+
+     @method modifier
+     @for Ember.Templates.helpers
+     @public
+     @since 3.27.0
+     */
+    export {};
+}

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

@@ -0,0 +1,77 @@
+declare module '@ember/-internals/glimmer/lib/helpers/mut' {
+    /**
+      The `mut` helper lets you __clearly specify__ that a child `Component` can update the
+      (mutable) value passed to it, which will __change the value of the parent component__.
+
+      To specify that a parameter is mutable, when invoking the child `Component`:
+
+      ```handlebars
+      <MyChild @childClickCount={{fn (mut totalClicks)}} />
+      ```
+
+       or
+
+      ```handlebars
+      {{my-child childClickCount=(mut totalClicks)}}
+      ```
+
+      The child `Component` can then modify the parent's value just by modifying its own
+      property:
+
+      ```javascript
+      // my-child.js
+      export default Component.extend({
+        click() {
+          this.incrementProperty('childClickCount');
+        }
+      });
+      ```
+
+      Note that for curly components (`{{my-component}}`) the bindings are already mutable,
+      making the `mut` unnecessary.
+
+      Additionally, the `mut` helper can be combined with the `fn` helper to
+      mutate a value. For example:
+
+      ```handlebars
+      <MyChild @childClickCount={{this.totalClicks}} @click-count-change={{fn (mut totalClicks))}} />
+      ```
+
+      or
+
+      ```handlebars
+      {{my-child childClickCount=totalClicks click-count-change=(fn (mut totalClicks))}}
+      ```
+
+      The child `Component` would invoke the function with the new click value:
+
+      ```javascript
+      // my-child.js
+      export default Component.extend({
+        click() {
+          this.get('click-count-change')(this.get('childClickCount') + 1);
+        }
+      });
+      ```
+
+      The `mut` helper changes the `totalClicks` value to what was provided as the `fn` argument.
+
+      The `mut` helper, when used with `fn`, will return a function that
+      sets the value passed to `mut` to its first argument. As an example, we can create a
+      button that increments a value passing the value directly to the `fn`:
+
+      ```handlebars
+      {{! inc helper is not provided by Ember }}
+      <button onclick={{fn (mut count) (inc count)}}>
+        Increment count
+      </button>
+      ```
+
+      @method mut
+      @param {Object} [attr] the "two-way" attribute that can be modified.
+      @for Ember.Templates.helpers
+      @public
+    */
+    const _default: object;
+    export default _default;
+}

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

@@ -0,0 +1,20 @@
+declare module '@ember/-internals/glimmer/lib/helpers/page-title' {
+    /**
+    @module ember
+    */
+    /**
+      `page-title` allows you to set the title of any page in your application and
+      append additional titles for each route. For complete documentation, see
+      https://github.com/ember-cli/ember-page-title.
+
+      ```handlebars
+      {{page-title "My Page Title" }}
+      ```
+
+      @method page-title
+      @for Ember.Templates.helpers
+      @param {String} param
+      @public
+    */
+    export {};
+}

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

@@ -0,0 +1,119 @@
+declare module '@ember/-internals/glimmer/lib/helpers/readonly' {
+    /**
+      The `readonly` helper let's you specify that a binding is one-way only,
+      instead of two-way.
+      When you pass a `readonly` binding from an outer context (e.g. parent component),
+      to to an inner context (e.g. child component), you are saying that changing that
+      property in the inner context does not change the value in the outer context.
+
+      To specify that a binding is read-only, when invoking the child `Component`:
+
+      ```app/components/my-parent.js
+      export default Component.extend({
+        totalClicks: 3
+      });
+      ```
+
+      ```app/templates/components/my-parent.hbs
+      {{log totalClicks}} // -> 3
+      <MyChild @childClickCount={{readonly totalClicks}} />
+      ```
+      ```
+      {{my-child childClickCount=(readonly totalClicks)}}
+      ```
+
+      Now, when you update `childClickCount`:
+
+      ```app/components/my-child.js
+      export default Component.extend({
+        click() {
+          this.incrementProperty('childClickCount');
+        }
+      });
+      ```
+
+      The value updates in the child component, but not the parent component:
+
+      ```app/templates/components/my-child.hbs
+      {{log childClickCount}} //-> 4
+      ```
+
+      ```app/templates/components/my-parent.hbs
+      {{log totalClicks}} //-> 3
+      <MyChild @childClickCount={{readonly totalClicks}} />
+      ```
+      or
+      ```app/templates/components/my-parent.hbs
+      {{log totalClicks}} //-> 3
+      {{my-child childClickCount=(readonly totalClicks)}}
+      ```
+
+      ### Objects and Arrays
+
+      When passing a property that is a complex object (e.g. object, array) instead of a primitive object (e.g. number, string),
+      only the reference to the object is protected using the readonly helper.
+      This means that you can change properties of the object both on the parent component, as well as the child component.
+      The `readonly` binding behaves similar to the `const` keyword in JavaScript.
+
+      Let's look at an example:
+
+      First let's set up the parent component:
+
+      ```app/components/my-parent.js
+      import Component from '@ember/component';
+
+      export default Component.extend({
+        clicks: null,
+
+        init() {
+          this._super(...arguments);
+          this.set('clicks', { total: 3 });
+        }
+      });
+      ```
+
+      ```app/templates/components/my-parent.hbs
+      {{log clicks.total}} //-> 3
+      <MyChild @childClicks={{readonly clicks}} />
+      ```
+      ```app/templates/components/my-parent.hbs
+      {{log clicks.total}} //-> 3
+      {{my-child childClicks=(readonly clicks)}}
+      ```
+
+      Now, if you update the `total` property of `childClicks`:
+
+      ```app/components/my-child.js
+      import Component from '@ember/component';
+
+      export default Component.extend({
+        click() {
+          this.get('clicks').incrementProperty('total');
+        }
+      });
+      ```
+
+      You will see the following happen:
+
+      ```app/templates/components/my-parent.hbs
+      {{log clicks.total}} //-> 4
+      <MyChild @childClicks={{readonly clicks}} />
+      ```
+      or
+      ```app/templates/components/my-parent.hbs
+      {{log clicks.total}} //-> 4
+      {{my-child childClicks=(readonly clicks)}}
+      ```
+
+      ```app/templates/components/my-child.hbs
+      {{log childClicks.total}} //-> 4
+      ```
+
+      @method readonly
+      @param {Object} [attr] the read-only attribute.
+      @for Ember.Templates.helpers
+      @private
+    */
+    const _default: object;
+    export default _default;
+}

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

@@ -0,0 +1,34 @@
+declare module '@ember/-internals/glimmer/lib/helpers/unbound' {
+    /**
+    @module ember
+    */
+    /**
+      The `{{unbound}}` helper disconnects the one-way binding of a property,
+      essentially freezing its value at the moment of rendering. For example,
+      in this example the display of the variable `name` will not change even
+      if it is set with a new value:
+
+      ```handlebars
+      {{unbound this.name}}
+      ```
+
+      Like any helper, the `unbound` helper can accept a nested helper expression.
+      This allows for custom helpers to be rendered unbound:
+
+      ```handlebars
+      {{unbound (some-custom-helper)}}
+      {{unbound (capitalize this.name)}}
+      {{! You can use any helper, including unbound, in a nested expression }}
+      {{capitalize (unbound this.name)}}
+      ```
+
+      The `unbound` helper only accepts a single argument, and it return an
+      unbound value.
+
+      @method unbound
+      @for Ember.Templates.helpers
+      @public
+    */
+    const _default: object;
+    export default _default;
+}

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

@@ -0,0 +1,8 @@
+declare module '@ember/-internals/glimmer/lib/helpers/unique-id' {
+    /**
+    @module ember
+    */
+    const _default: object;
+    export default _default;
+    export function uniqueId(): string;
+}

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

@@ -0,0 +1,27 @@
+declare module '@ember/-internals/glimmer/lib/modifiers/action' {
+    import type { InternalOwner } from "@ember/-internals/owner";
+    import type { CapturedNamedArguments, CapturedPositionalArguments } from "@glimmer/interfaces";
+    import type { SimpleElement } from "@simple-dom/interface";
+    export let ActionHelper: {
+        registeredActions: Record<string, ActionState>;
+        registerAction(actionState: ActionState): number;
+        unregisterAction(actionState: ActionState): void;
+    };
+    export class ActionState {
+        element: SimpleElement;
+        owner: InternalOwner;
+        actionId: number;
+        actionName: any;
+        actionArgs: any;
+        namedArgs: CapturedNamedArguments;
+        positional: CapturedPositionalArguments;
+        implicitTarget: any;
+        eventName: any;
+        tag: import("@glimmer/interfaces").UpdatableTag;
+        constructor(element: SimpleElement, owner: InternalOwner, actionId: number, actionArgs: any[], namedArgs: CapturedNamedArguments, positionalArgs: CapturedPositionalArguments);
+        getEventName(): unknown;
+        getActionArgs(): any[];
+        getTarget(): any;
+        handler(event: Event): boolean;
+    }
+}

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

@@ -0,0 +1,34 @@
+declare module '@ember/-internals/glimmer/lib/modifiers/internal' {
+    import type { InternalOwner } from "@ember/-internals/owner";
+    import type { CapturedArguments, Destroyable, InternalModifierManager as ModifierManager } from "@glimmer/interfaces";
+    import type { SimpleElement } from "@simple-dom/interface";
+    export default class InternalModifier {
+        protected owner: InternalOwner;
+        protected readonly element: Element;
+        protected readonly args: CapturedArguments;
+        static toString(): string;
+        constructor(owner: InternalOwner, element: Element, args: CapturedArguments);
+        install(): void;
+        remove(): void;
+        protected positional(index: number): unknown;
+        protected named(key: string): unknown;
+        toString(): string;
+    }
+    class InternalModifierState implements Destroyable {
+        readonly instance: InternalModifier;
+        constructor(instance: InternalModifier);
+    }
+    export abstract class InternalModifierManager implements ModifierManager<InternalModifierState, typeof InternalModifier> {
+        private ModifierClass;
+        private name;
+        constructor(ModifierClass: typeof InternalModifier, name: string);
+        create(owner: InternalOwner, element: SimpleElement, _definition: unknown, args: CapturedArguments): InternalModifierState;
+        getTag(): null;
+        abstract getDebugInstance(state: InternalModifierState): unknown;
+        getDebugName(): string;
+        install({ instance }: InternalModifierState): void;
+        update(): void;
+        getDestroyable({ instance }: InternalModifierState): Destroyable;
+    }
+    export {};
+}

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

@@ -0,0 +1,95 @@
+declare module '@ember/-internals/glimmer/lib/modifiers/on' {
+    /**
+    @module ember
+    */
+    /**
+      The `{{on}}` modifier lets you easily add event listeners (it uses
+      [EventTarget.addEventListener](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener)
+      internally).
+
+      For example, if you'd like to run a function on your component when a `<button>`
+      in the components template is clicked you might do something like:
+
+      ```app/components/like-post.hbs
+      <button {{on 'click' this.saveLike}}>Like this post!</button>
+      ```
+
+      ```app/components/like-post.js
+      import Component from '@glimmer/component';
+      import { action } from '@ember/object';
+
+      export default class LikePostComponent extends Component {
+        @action
+        saveLike() {
+          // someone likes your post!
+          // better send a request off to your server...
+        }
+      }
+      ```
+
+      ### Arguments
+
+      `{{on}}` accepts two positional arguments, and a few named arguments.
+
+      The positional arguments are:
+
+      - `event` -- the name to use when calling `addEventListener`
+      - `callback` -- the function to be passed to `addEventListener`
+
+      The named arguments are:
+
+      - capture -- a `true` value indicates that events of this type will be dispatched
+        to the registered listener before being dispatched to any EventTarget beneath it
+        in the DOM tree.
+      - once -- indicates that the listener should be invoked at most once after being
+        added. If true, the listener would be automatically removed when invoked.
+      - passive -- if `true`, indicates that the function specified by listener will never
+        call preventDefault(). If a passive listener does call preventDefault(), the user
+        agent will do nothing other than generate a console warning. See
+        [Improving scrolling performance with passive listeners](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Improving_scrolling_performance_with_passive_listeners)
+        to learn more.
+
+      The callback function passed to `{{on}}` will receive any arguments that are passed
+      to the event handler. Most commonly this would be the `event` itself.
+
+      If you would like to pass additional arguments to the function you should use
+      the `{{fn}}` helper.
+
+      For example, in our example case above if you'd like to pass in the post that
+      was being liked when the button is clicked you could do something like:
+
+      ```app/components/like-post.hbs
+      <button {{on 'click' (fn this.saveLike @post)}}>Like this post!</button>
+      ```
+
+      In this case, the `saveLike` function will receive two arguments: the click event
+      and the value of `@post`.
+
+      ### Function Context
+
+      In the example above, we used `@action` to ensure that `likePost` is
+      properly bound to the `items-list`, but let's explore what happens if we
+      left out `@action`:
+
+      ```app/components/like-post.js
+      import Component from '@glimmer/component';
+
+      export default class LikePostComponent extends Component {
+        saveLike() {
+          // ...snip...
+        }
+      }
+      ```
+
+      In this example, when the button is clicked `saveLike` will be invoked,
+      it will **not** have access to the component instance. In other
+      words, it will have no `this` context, so please make sure your functions
+      are bound (via `@action` or other means) before passing into `on`!
+
+      @method on
+      @for Ember.Templates.helpers
+      @public
+      @since 3.11.0
+    */
+    export {};
+}