@discourse/types 0.0.1 → 0.0.2

package/external-types/ember-source/types/stable/@ember/object/promise-proxy-mixin.d.ts

@@ -0,0 +1,167 @@
+declare module '@ember/object/promise-proxy-mixin' {
+    import Mixin from "@ember/object/mixin";
+    /**
+      A low level mixin making ObjectProxy promise-aware.
+
+      ```javascript
+      import { resolve } from 'rsvp';
+      import $ from 'jquery';
+      import ObjectProxy from '@ember/object/proxy';
+      import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
+
+      let ObjectPromiseProxy = ObjectProxy.extend(PromiseProxyMixin);
+
+      let proxy = ObjectPromiseProxy.create({
+        promise: resolve($.getJSON('/some/remote/data.json'))
+      });
+
+      proxy.then(function(json){
+         // the json
+      }, function(reason) {
+         // the reason why you have no json
+      });
+      ```
+
+      the proxy has bindable attributes which
+      track the promises life cycle
+
+      ```javascript
+      proxy.get('isPending')   //=> true
+      proxy.get('isSettled')  //=> false
+      proxy.get('isRejected')  //=> false
+      proxy.get('isFulfilled') //=> false
+      ```
+
+      When the $.getJSON completes, and the promise is fulfilled
+      with json, the life cycle attributes will update accordingly.
+      Note that $.getJSON doesn't return an ECMA specified promise,
+      it is useful to wrap this with an `RSVP.resolve` so that it behaves
+      as a spec compliant promise.
+
+      ```javascript
+      proxy.get('isPending')   //=> false
+      proxy.get('isSettled')   //=> true
+      proxy.get('isRejected')  //=> false
+      proxy.get('isFulfilled') //=> true
+      ```
+
+      As the proxy is an ObjectProxy, and the json now its content,
+      all the json properties will be available directly from the proxy.
+
+      ```javascript
+      // Assuming the following json:
+      {
+        firstName: 'Stefan',
+        lastName: 'Penner'
+      }
+
+      // both properties will accessible on the proxy
+      proxy.get('firstName') //=> 'Stefan'
+      proxy.get('lastName')  //=> 'Penner'
+      ```
+
+      @class PromiseProxyMixin
+      @public
+    */
+    interface PromiseProxyMixin<T> {
+        /**
+          If the proxied promise is rejected this will contain the reason
+          provided.
+      
+          @property reason
+          @default null
+          @public
+        */
+        reason: unknown;
+        /**
+          Once the proxied promise has settled this will become `false`.
+      
+          @property isPending
+          @default true
+          @public
+        */
+        readonly isPending: boolean;
+        /**
+          Once the proxied promise has settled this will become `true`.
+      
+          @property isSettled
+          @default false
+          @public
+        */
+        readonly isSettled: boolean;
+        /**
+          Will become `true` if the proxied promise is rejected.
+      
+          @property isRejected
+          @default false
+          @public
+        */
+        isRejected: boolean;
+        /**
+          Will become `true` if the proxied promise is fulfilled.
+      
+          @property isFulfilled
+          @default false
+          @public
+        */
+        isFulfilled: boolean;
+        /**
+          The promise whose fulfillment value is being proxied by this object.
+      
+          This property must be specified upon creation, and should not be
+          changed once created.
+      
+          Example:
+      
+          ```javascript
+          import ObjectProxy from '@ember/object/proxy';
+          import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
+      
+          ObjectProxy.extend(PromiseProxyMixin).create({
+            promise: <thenable>
+          });
+          ```
+      
+          @property promise
+          @public
+        */
+        promise: Promise<T>;
+        /**
+          An alias to the proxied promise's `then`.
+      
+          See RSVP.Promise.then.
+      
+          @method then
+          @param {Function} callback
+          @return {RSVP.Promise}
+          @public
+        */
+        then: this["promise"]["then"];
+        /**
+          An alias to the proxied promise's `catch`.
+      
+          See RSVP.Promise.catch.
+      
+          @method catch
+          @param {Function} callback
+          @return {RSVP.Promise}
+          @since 1.3.0
+          @public
+        */
+        catch: this["promise"]["catch"];
+        /**
+          An alias to the proxied promise's `finally`.
+      
+          See RSVP.Promise.finally.
+      
+          @method finally
+          @param {Function} callback
+          @return {RSVP.Promise}
+          @since 1.3.0
+          @public
+        */
+        finally: this["promise"]["finally"];
+    }
+    const PromiseProxyMixin: Mixin;
+    export default PromiseProxyMixin;
+}

package/external-types/ember-source/types/stable/@ember/object/proxy.d.ts

@@ -0,0 +1,100 @@
+declare module '@ember/object/proxy' {
+    /**
+    @module @ember/object/proxy
+    */
+    import { FrameworkObject } from "@ember/object/-internals";
+    import { _ProxyMixin } from "@ember/-internals/runtime";
+    /**
+      `ObjectProxy` forwards all properties not defined by the proxy itself
+      to a proxied `content` object.
+
+      ```javascript
+      import EmberObject from '@ember/object';
+      import ObjectProxy from '@ember/object/proxy';
+
+      let exampleObject = EmberObject.create({
+        name: 'Foo'
+      });
+
+      let exampleProxy = ObjectProxy.create({
+        content: exampleObject
+      });
+
+      // Access and change existing properties
+      exampleProxy.get('name');          // 'Foo'
+      exampleProxy.set('name', 'Bar');
+      exampleObject.get('name');         // 'Bar'
+
+      // Create new 'description' property on `exampleObject`
+      exampleProxy.set('description', 'Foo is a whizboo baz');
+      exampleObject.get('description');  // 'Foo is a whizboo baz'
+      ```
+
+      While `content` is unset, setting a property to be delegated will throw an
+      Error.
+
+      ```javascript
+      import ObjectProxy from '@ember/object/proxy';
+
+      let exampleProxy = ObjectProxy.create({
+        content: null,
+        flag: null
+      });
+      exampleProxy.set('flag', true);
+      exampleProxy.get('flag');         // true
+      exampleProxy.get('foo');          // undefined
+      exampleProxy.set('foo', 'data');  // throws Error
+      ```
+
+      Delegated properties can be bound to and will change when content is updated.
+
+      Computed properties on the proxy itself can depend on delegated properties.
+
+      ```javascript
+      import { computed } from '@ember/object';
+      import ObjectProxy from '@ember/object/proxy';
+
+      ProxyWithComputedProperty = ObjectProxy.extend({
+        fullName: computed('firstName', 'lastName', function() {
+          var firstName = this.get('firstName'),
+              lastName = this.get('lastName');
+          if (firstName && lastName) {
+            return firstName + ' ' + lastName;
+          }
+          return firstName || lastName;
+        })
+      });
+
+      let exampleProxy = ProxyWithComputedProperty.create();
+
+      exampleProxy.get('fullName');  // undefined
+      exampleProxy.set('content', {
+        firstName: 'Tom', lastName: 'Dale'
+      }); // triggers property change for fullName on proxy
+
+      exampleProxy.get('fullName');  // 'Tom Dale'
+      ```
+
+      @class ObjectProxy
+      @extends EmberObject
+      @uses Ember.ProxyMixin
+      @public
+    */
+    interface ObjectProxy<Content = unknown> extends _ProxyMixin<Content> {
+        get<K extends keyof Content>(keyName: K): Content[K];
+        get<K extends keyof this>(keyname: K): this[K];
+        get(keyName: string): unknown;
+        set<K extends keyof Content>(keyName: K, value: Content[K]): Content[K];
+        set<K extends keyof this>(keyName: K, value: this[K]): this[K];
+        set(keyName: string): unknown;
+        getProperties<K extends keyof Content | keyof this>(list: K[]): Pick<Content, Exclude<K, keyof this>> & Pick<this, Exclude<K, keyof Content>>;
+        getProperties<K extends keyof Content | keyof this>(...list: K[]): Pick<Content, Exclude<K, keyof this>> & Pick<this, Exclude<K, keyof Content>>;
+        getProperties<K extends string>(list: K[]): Record<K, unknown>;
+        getProperties<K extends string>(...list: K[]): Record<K, unknown>;
+        setProperties<K extends keyof Content | keyof this, Hash extends Partial<Pick<Content, Exclude<K, keyof this>> & Pick<this, Exclude<K, keyof Content>>>>(hash: Hash): Hash;
+        setProperties<T extends Record<string, unknown>>(hash: T): T;
+    }
+    class ObjectProxy<Content = unknown> extends FrameworkObject {
+    }
+    export default ObjectProxy;
+}

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

@@ -0,0 +1,80 @@
+declare module '@ember/owner' {
+    /**
+      Ember’s dependency injection system is built on the idea of an "owner": an
+      object responsible for managing items which can be registered and looked up
+      with the system.
+
+      This module does not provide any concrete instances of owners. Instead, it
+      defines the core type, `Owner`, which specifies the public API contract for an
+      owner. The primary concrete implementations of `Owner` are `EngineInstance`,
+      from `@ember/engine/instance`, and its `ApplicationInstance` subclass, from
+      `@ember/application/instance`.
+
+      Along with `Owner` itself, this module provides a number of supporting types
+      related to Ember's DI system:
+
+      - `Factory`, Ember's primary interface for something which can create class
+        instances registered with the DI system.
+
+      - `FactoryManager`, an interface for inspecting a `Factory`'s class.
+
+      - `Resolver`, an interface defining the contract for the object responsible
+        for mapping string names to the corresponding classes. For example, when you
+        write `@service('session')`, a resolver is responsible to map that back to
+        the `Session` service class in your codebase. Normally, this is handled for
+        you automatically with `ember-resolver`, which is the main implementor of
+        this interface.
+
+      For more details on each, see their per-item docs.
+
+      @module @ember/owner
+      @public
+    */
+    import { type default as Owner } from "@ember/-internals/owner";
+    /**
+      Framework objects in an Ember application (components, services, routes, etc.)
+      are created via a factory and dependency injection system. Each of these
+      objects is the responsibility of an "owner", which handled its
+      instantiation and manages its lifetime.
+
+      `getOwner` fetches the owner object responsible for an instance. This can
+      be used to lookup or resolve other class instances, or register new factories
+      into the owner.
+
+      For example, this component dynamically looks up a service based on the
+      `audioType` passed as an argument:
+
+      ```app/components/play-audio.js
+      import Component from '@glimmer/component';
+      import { action } from '@ember/object';
+      import { getOwner } from '@ember/owner';
+
+      // Usage:
+      //
+      //   <PlayAudio @audioType={{@model.audioType}} @audioFile={{@model.file}}/>
+      //
+      export default class extends Component {
+        get audioService() {
+          return getOwner(this)?.lookup(`service:${this.args.audioType}`);
+        }
+
+        @action
+        onPlay() {
+          this.audioService?.play(this.args.audioFile);
+        }
+      }
+      ```
+
+      @method getOwner
+      @static
+      @for @ember/owner
+      @param {Object} object An object with an owner.
+      @return {Object} An owner object.
+      @since 2.3.0
+      @public
+    */
+    const getOwner: (object: object) => Owner | undefined;
+    export { getOwner };
+    export type { Owner as default };
+    export { setOwner, type FullName, type RegisterOptions, type Factory, type FactoryManager, type KnownForTypeResult, type Resolver, type DIRegistry, } from "@ember/-internals/owner";
+}

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

@@ -0,0 +1,63 @@
+declare module '@ember/renderer' {
+    /**
+      @module @ember/renderer
+      @public
+    */
+    /**
+     * @class Renderer
+     * @public
+     */
+    /**
+      Returns a promise which will resolve when rendering has completed. In
+      this context, rendering is completed when all auto-tracked state that is
+      consumed in the template (including any tracked state in models, services,
+      etc. that are then used in a template) has been updated in the DOM.
+
+      For example, in a test you might want to update some tracked state and
+      then run some assertions after rendering has completed. You _could_ use
+      `await settled()` in that location, but in some contexts you don't want to
+      wait for full settledness (which includes test waiters, pending AJAX/fetch,
+      run loops, etc) but instead only want to know when that updated value has
+      been rendered in the DOM. **THAT** is what `await renderSettled()` is
+      _perfect_ for.
+
+      ```js
+      import { renderSettled } from '@ember/renderer';
+      import { render } from '@ember/test-helpers';
+      import { tracked } from '@glimmer/tracking';
+      import { hbs } from 'ember-cli-htmlbars';
+      import { setupRenderingTest } from 'my-app/tests/helpers';
+      import { module, test } from 'qunit';
+
+      module('Integration | Component | profile-card', function (hooks) {
+        setupRenderingTest(hooks);
+
+        test("it renders the person's name", async function (assert) {
+          class Person {
+            @tracked name = '';
+          }
+
+          this.person = new Person();
+          this.person.name = 'John';
+
+          await render(hbs`
+            <ProfileCard @name={{this.person.name}} />
+          `);
+
+          assert.dom().hasText('John');
+
+          this.person.name = 'Jane';
+
+          await renderSettled(); // Wait until rendering has completed.
+
+          assert.dom().hasText('Jane');
+        });
+      });
+      ```
+
+      @method renderSettled
+      @returns {Promise<void>} a promise which fulfills when rendering has completed
+      @public
+    */
+    export { renderSettled } from "@ember/-internals/glimmer";
+}

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

@@ -0,0 +1,11 @@
+declare module '@ember/routing/-internals' {
+    export { default as RouterState } from "@ember/routing/lib/router_state";
+    export { default as RoutingService } from "@ember/routing/lib/routing-service";
+    export { type RouteArgs, prefixRouteNameArg } from "@ember/routing/lib/utils";
+    export { default as generateController, generateControllerFactory, } from "@ember/routing/lib/generate_controller";
+    export { default as BucketCache } from "@ember/routing/lib/cache";
+    export { default as DSL, type DSLCallback } from "@ember/routing/lib/dsl";
+    export type { EngineRouteInfo } from "@ember/routing/lib/engines";
+    export type { RouteInfo, RouteInfoWithAttributes } from "@ember/routing/lib/route-info";
+    export { default as controllerFor } from "@ember/routing/lib/controller_for";
+}

package/external-types/ember-source/types/stable/@ember/routing/hash-location.d.ts

@@ -0,0 +1,109 @@
+declare module '@ember/routing/hash-location' {
+    import EmberObject from "@ember/object";
+    import type { default as EmberLocation, UpdateCallback } from "@ember/routing/location";
+    /**
+    @module @ember/routing/hash-location
+    */
+    /**
+      `HashLocation` implements the location API using the browser's
+      hash. At present, it relies on a `hashchange` event existing in the
+      browser.
+
+      Using `HashLocation` results in URLs with a `#` (hash sign) separating the
+      server side URL portion of the URL from the portion that is used by Ember.
+
+      Example:
+
+      ```app/router.js
+      Router.map(function() {
+        this.route('posts', function() {
+          this.route('new');
+        });
+      });
+
+      Router.reopen({
+        location: 'hash'
+      });
+      ```
+
+      This will result in a posts.new url of `/#/posts/new`.
+
+      @class HashLocation
+      @extends EmberObject
+      @protected
+    */
+    export default class HashLocation extends EmberObject implements EmberLocation {
+        _hashchangeHandler?: EventListener;
+        private _location?;
+        location: Location;
+        init(): void;
+        /**
+          @private
+      
+          Returns normalized location.hash
+      
+          @since 1.5.1
+          @method getHash
+        */
+        getHash(): string;
+        /**
+          Returns the normalized URL, constructed from `location.hash`.
+      
+          e.g. `#/foo` => `/foo` as well as `#/foo#bar` => `/foo#bar`.
+      
+          By convention, hashed paths must begin with a forward slash, otherwise they
+          are not treated as a path so we can distinguish intent.
+      
+          @private
+          @method getURL
+        */
+        getURL(): string;
+        /**
+          Set the `location.hash` and remembers what was set. This prevents
+          `onUpdateURL` callbacks from triggering when the hash was set by
+          `HashLocation`.
+      
+          @private
+          @method setURL
+          @param path {String}
+        */
+        setURL(path: string): void;
+        /**
+          Uses location.replace to update the url without a page reload
+          or history modification.
+      
+          @private
+          @method replaceURL
+          @param path {String}
+        */
+        replaceURL(path: string): void;
+        lastSetURL: string | null;
+        /**
+          Register a callback to be invoked when the hash changes. These
+          callbacks will execute when the user presses the back or forward
+          button, but not after `setURL` is invoked.
+      
+          @private
+          @method onUpdateURL
+          @param callback {Function}
+        */
+        onUpdateURL(callback: UpdateCallback): void;
+        /**
+          Given a URL, formats it to be placed into the page as part
+          of an element's `href` attribute.
+      
+          @private
+          @method formatURL
+          @param url {String}
+        */
+        formatURL(url: string): string;
+        /**
+          Cleans up the HashLocation event listener.
+      
+          @private
+          @method willDestroy
+        */
+        willDestroy(): void;
+        _removeEventListener(): void;
+    }
+}

package/external-types/ember-source/types/stable/@ember/routing/history-location.d.ts

@@ -0,0 +1,142 @@
+declare module '@ember/routing/history-location' {
+    import EmberObject from "@ember/object";
+    import type { default as EmberLocation, UpdateCallback } from "@ember/routing/location";
+    /**
+      HistoryLocation implements the location API using the browser's
+      history.pushState API.
+
+      Using `HistoryLocation` results in URLs that are indistinguishable from a
+      standard URL. This relies upon the browser's `history` API.
+
+      Example:
+
+      ```app/router.js
+      Router.map(function() {
+        this.route('posts', function() {
+          this.route('new');
+        });
+      });
+
+      Router.reopen({
+        location: 'history'
+      });
+      ```
+
+      This will result in a posts.new url of `/posts/new`.
+
+      Keep in mind that your server must serve the Ember app at all the routes you
+      define.
+
+      Using `HistoryLocation` will also result in location states being recorded by
+      the browser `history` API with the following schema:
+
+      ```
+      window.history.state -> { path: '/', uuid: '3552e730-b4a6-46bd-b8bf-d8c3c1a97e0a' }
+      ```
+
+      This allows each in-app location state to be tracked uniquely across history
+      state changes via the `uuid` field.
+
+      @class HistoryLocation
+      @extends EmberObject
+      @protected
+    */
+    export default class HistoryLocation extends EmberObject implements EmberLocation {
+        location: Location;
+        baseURL: string;
+        history?: Window["history"];
+        _previousURL?: string;
+        _popstateHandler?: EventListener;
+        /**
+          Will be pre-pended to path upon state change
+      
+          @property rootURL
+          @default '/'
+          @private
+        */
+        rootURL: string;
+        /**
+          @private
+      
+          Returns normalized location.hash
+      
+          @method getHash
+        */
+        getHash(): string;
+        init(): void;
+        /**
+          Used to set state on first call to setURL
+      
+          @private
+          @method initState
+        */
+        initState(): void;
+        /**
+          Returns the current `location.pathname` without `rootURL` or `baseURL`
+      
+          @private
+          @method getURL
+          @return url {String}
+        */
+        getURL(): string;
+        /**
+          Uses `history.pushState` to update the url without a page reload.
+      
+          @private
+          @method setURL
+          @param path {String}
+        */
+        setURL(path: string): void;
+        /**
+          Uses `history.replaceState` to update the url without a page reload
+          or history modification.
+      
+          @private
+          @method replaceURL
+          @param path {String}
+        */
+        replaceURL(path: string): void;
+        /**
+         Pushes a new state.
+      
+         @private
+         @method pushState
+         @param path {String}
+        */
+        pushState(path: string): void;
+        /**
+         Replaces the current state.
+      
+         @private
+         @method replaceState
+         @param path {String}
+        */
+        replaceState(path: string): void;
+        /**
+          Register a callback to be invoked whenever the browser
+          history changes, including using forward and back buttons.
+      
+          @private
+          @method onUpdateURL
+          @param callback {Function}
+        */
+        onUpdateURL(callback: UpdateCallback): void;
+        /**
+          Formats url to be placed into href attribute.
+      
+          @private
+          @method formatURL
+          @param url {String}
+          @return formatted url {String}
+        */
+        formatURL(url: string): string;
+        /**
+          Cleans up the HistoryLocation event listener.
+      
+          @private
+          @method willDestroy
+        */
+        willDestroy(): void;
+        _removeEventListener(): void;
+    }
+}

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

@@ -0,0 +1,3 @@
+declare module '@ember/routing' {
+    export { LinkTo } from "@ember/-internals/glimmer";
+}

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

@@ -0,0 +1,16 @@
+declare module '@ember/routing/lib/cache' {
+    /**
+      A two-tiered cache with support for fallback values when doing lookups.
+      Uses "buckets" and then "keys" to cache values.
+
+      @private
+      @class BucketCache
+    */
+    export default class BucketCache {
+        cache: Map<string, Map<string, any>>;
+        constructor();
+        has(bucketKey: string): boolean;
+        stash(bucketKey: string, key: string, value: any): void;
+        lookup(bucketKey: string, prop: string, defaultValue: any): any;
+    }
+}