@discourse/types 0.0.0 → 0.0.2

package/external-types/ember-source/types/stable/ember-testing/lib/adapters/adapter.d.ts

@@ -0,0 +1,56 @@
+declare module 'ember-testing/lib/adapters/adapter' {
+    import EmberObject from "@ember/object";
+    /**
+     @module @ember/test
+    */
+    /**
+      The primary purpose of this class is to create hooks that can be implemented
+      by an adapter for various test frameworks.
+
+      @class TestAdapter
+      @public
+    */
+    interface Adapter extends EmberObject {
+        asyncStart(): void;
+        asyncEnd(): void;
+        exception(error: unknown): never;
+    }
+    const Adapter: Readonly<typeof EmberObject> & (new (owner?: import("@ember/owner").default | undefined) => EmberObject) & {
+        /**
+          This callback will be called whenever an async operation is about to start.
+      
+          Override this to call your framework's methods that handle async
+          operations.
+      
+          @public
+          @method asyncStart
+        */
+        asyncStart(): void;
+        /**
+          This callback will be called whenever an async operation has completed.
+      
+          @public
+          @method asyncEnd
+        */
+        asyncEnd(): void;
+        /**
+          Override this method with your testing framework's false assertion.
+          This function is called whenever an exception occurs causing the testing
+          promise to fail.
+      
+          QUnit example:
+      
+          ```javascript
+            exception: function(error) {
+              ok(false, error);
+            };
+          ```
+      
+          @public
+          @method exception
+          @param {String} error The exception to be raised.
+        */
+        exception(error: unknown): never;
+    };
+    export default Adapter;
+}

package/external-types/ember-source/types/stable/ember-testing/lib/adapters/qunit.d.ts

@@ -0,0 +1,29 @@
+declare module 'ember-testing/lib/adapters/qunit' {
+    import Adapter from "ember-testing/lib/adapters/adapter";
+    /**
+       @module ember
+    */
+    /**
+      This class implements the methods defined by TestAdapter for the
+      QUnit testing framework.
+
+      @class QUnitAdapter
+      @namespace Ember.Test
+      @extends TestAdapter
+      @public
+    */
+    interface QUnitAdapter extends Adapter {
+        doneCallbacks: Array<Function>;
+    }
+    const QUnitAdapter: Readonly<Readonly<typeof import("@ember/object").default> & (new (owner?: import("@ember/owner").default | undefined) => import("@ember/object").default) & {
+        asyncStart(): void;
+        asyncEnd(): void;
+        exception(error: unknown): never;
+    }> & (new (owner?: import("@ember/owner").default | undefined) => import("@ember/object").default) & {
+        init(this: QUnitAdapter): void;
+        asyncStart(this: QUnitAdapter): void;
+        asyncEnd(this: QUnitAdapter): void;
+        exception(error: unknown): void;
+    };
+    export default QUnitAdapter;
+}

package/external-types/ember-source/types/stable/ember-testing/lib/ext/application.d.ts

@@ -0,0 +1,12 @@
+declare module 'ember-testing/lib/ext/application' {
+    import type Application from "@ember/application";
+    export interface TestableApp extends Application {
+        testing?: boolean;
+        testHelpers: Record<string, (...args: unknown[]) => unknown>;
+        originalMethods: Record<string, (...args: unknown[]) => unknown>;
+        setupForTesting(): void;
+        helperContainer: object | null;
+        injectTestHelpers(helperContainer: unknown): void;
+        removeTestHelpers(): void;
+    }
+}

package/external-types/ember-source/types/stable/ember-testing/lib/ext/rsvp.d.ts

@@ -0,0 +1,4 @@
+declare module 'ember-testing/lib/ext/rsvp' {
+    import { RSVP } from "@ember/-internals/runtime";
+    export default RSVP;
+}

package/external-types/ember-source/types/stable/ember-testing/lib/helpers/and_then.d.ts

@@ -0,0 +1,4 @@
+declare module 'ember-testing/lib/helpers/and_then' {
+    import type { TestableApp } from "ember-testing/lib/ext/application";
+    export default function andThen(app: TestableApp, callback: (app: TestableApp) => unknown): unknown;
+}

package/external-types/ember-source/types/stable/ember-testing/lib/helpers/current_path.d.ts

@@ -0,0 +1,22 @@
+declare module 'ember-testing/lib/helpers/current_path' {
+    import type Application from "@ember/application";
+    /**
+      Returns the current path.
+
+    Example:
+
+    ```javascript
+    function validateURL() {
+      equal(currentPath(), 'some.path.index', "correct path was transitioned into.");
+    }
+
+    click('#some-link-id').then(validateURL);
+    ```
+
+    @method currentPath
+    @return {Object} The currently active path.
+    @since 1.5.0
+    @public
+    */
+    export default function currentPath(app: Application): string | null;
+}

package/external-types/ember-source/types/stable/ember-testing/lib/helpers/current_route_name.d.ts

@@ -0,0 +1,21 @@
+declare module 'ember-testing/lib/helpers/current_route_name' {
+    import type Application from "@ember/application";
+    /**
+      Returns the currently active route name.
+
+    Example:
+
+    ```javascript
+    function validateRouteName() {
+      equal(currentRouteName(), 'some.path', "correct route was transitioned into.");
+    }
+    visit('/some/path').then(validateRouteName)
+    ```
+
+    @method currentRouteName
+    @return {Object} The name of the currently active route.
+    @since 1.5.0
+    @public
+    */
+    export default function currentRouteName(app: Application): string | null;
+}

package/external-types/ember-source/types/stable/ember-testing/lib/helpers/current_url.d.ts

@@ -0,0 +1,22 @@
+declare module 'ember-testing/lib/helpers/current_url' {
+    import type Application from "@ember/application";
+    /**
+      Returns the current URL.
+
+    Example:
+
+    ```javascript
+    function validateURL() {
+      equal(currentURL(), '/some/path', "correct URL was transitioned into.");
+    }
+
+    click('#some-link-id').then(validateURL);
+    ```
+
+    @method currentURL
+    @return {Object} The currently active URL.
+    @since 1.5.0
+    @public
+    */
+    export default function currentURL(app: Application): string;
+}

package/external-types/ember-source/types/stable/ember-testing/lib/helpers/pause_test.d.ts

@@ -0,0 +1,53 @@
+declare module 'ember-testing/lib/helpers/pause_test' {
+    /// <reference types="rsvp" />
+    /**
+    @module ember
+    */
+    import { RSVP } from "@ember/-internals/runtime";
+    /**
+     Resumes a test paused by `pauseTest`.
+
+     @method resumeTest
+     @return {void}
+     @public
+    */
+    export function resumeTest(): void;
+    /**
+     Pauses the current test - this is useful for debugging while testing or for test-driving.
+     It allows you to inspect the state of your application at any point.
+     Example (The test will pause before clicking the button):
+
+     ```javascript
+     visit('/')
+     return pauseTest();
+     click('.btn');
+     ```
+
+     You may want to turn off the timeout before pausing.
+
+     qunit (timeout available to use as of 2.4.0):
+
+     ```
+     visit('/');
+     assert.timeout(0);
+     return pauseTest();
+     click('.btn');
+     ```
+
+     mocha (timeout happens automatically as of ember-mocha v0.14.0):
+
+     ```
+     visit('/');
+     this.timeout(0);
+     return pauseTest();
+     click('.btn');
+     ```
+
+
+     @since 1.9.0
+     @method pauseTest
+     @return {Object} A promise that will never resolve
+     @public
+    */
+    export function pauseTest(): RSVP.default.Promise<unknown>;
+}

package/external-types/ember-source/types/stable/ember-testing/lib/helpers/visit.d.ts

@@ -0,0 +1,22 @@
+declare module 'ember-testing/lib/helpers/visit' {
+    import type { TestableApp } from "ember-testing/lib/ext/application";
+    /**
+      Loads a route, sets up any controllers, and renders any templates associated
+      with the route as though a real user had triggered the route change while
+      using your app.
+
+      Example:
+
+      ```javascript
+      visit('posts/index').then(function() {
+        // assert something
+      });
+      ```
+
+      @method visit
+      @param {String} url the name of the route
+      @return {RSVP.Promise<undefined>}
+      @public
+    */
+    export default function visit(app: TestableApp, url: string): unknown;
+}

package/external-types/ember-source/types/stable/ember-testing/lib/helpers/wait.d.ts

@@ -0,0 +1,34 @@
+declare module 'ember-testing/lib/helpers/wait' {
+    import type Application from "@ember/application";
+    /**
+      Causes the run loop to process any pending events. This is used to ensure that
+      any async operations from other helpers (or your assertions) have been processed.
+
+      This is most often used as the return value for the helper functions (see 'click',
+      'fillIn','visit',etc). However, there is a method to register a test helper which
+      utilizes this method without the need to actually call `wait()` in your helpers.
+
+      The `wait` helper is built into `registerAsyncHelper` by default. You will not need
+      to `return app.testHelpers.wait();` - the wait behavior is provided for you.
+
+      Example:
+
+      ```javascript
+      import { registerAsyncHelper } from '@ember/test';
+
+      registerAsyncHelper('loginUser', function(app, username, password) {
+        visit('secured/path/here')
+          .fillIn('#username', username)
+          .fillIn('#password', password)
+          .click('.submit');
+      });
+      ```
+
+      @method wait
+      @param {Object} value The value to be returned.
+      @return {RSVP.Promise<any>} Promise that resolves to the passed value.
+      @public
+      @since 1.0.0
+    */
+    export default function wait<T>(app: Application, value: T): Promise<T>;
+}

package/external-types/ember-source/types/stable/ember-testing/lib/helpers.d.ts

@@ -0,0 +1,3 @@
+declare module 'ember-testing/lib/helpers' {
+    export {};
+}

package/external-types/ember-source/types/stable/ember-testing/lib/initializers.d.ts

@@ -0,0 +1,3 @@
+declare module 'ember-testing/lib/initializers' {
+    export {};
+}

package/external-types/ember-source/types/stable/ember-testing/lib/public-api.d.ts

@@ -0,0 +1,10 @@
+declare module 'ember-testing/lib/public-api' {
+    export { default as Test } from "ember-testing/lib/test";
+    export { default as Adapter } from "ember-testing/lib/adapters/adapter";
+    export { default as setupForTesting } from "ember-testing/lib/setup_for_testing";
+    export { default as QUnitAdapter } from "ember-testing/lib/adapters/qunit";
+    import "ember-testing/lib/ext/application";
+    import "ember-testing/lib/ext/rsvp";
+    import "ember-testing/lib/helpers";
+    import "ember-testing/lib/initializers";
+}

package/external-types/ember-source/types/stable/ember-testing/lib/setup_for_testing.d.ts

@@ -0,0 +1,15 @@
+declare module 'ember-testing/lib/setup_for_testing' {
+    /**
+      Sets Ember up for testing. This is useful to perform
+      basic setup steps in order to unit test.
+
+      Use `App.setupForTesting` to perform integration tests (full
+      application testing).
+
+      @method setupForTesting
+      @namespace Ember
+      @since 1.5.0
+      @private
+    */
+    export default function setupForTesting(): void;
+}

package/external-types/ember-source/types/stable/ember-testing/lib/test/adapter.d.ts

@@ -0,0 +1,7 @@
+declare module 'ember-testing/lib/test/adapter' {
+    import type Adapter from "ember-testing/lib/adapters/adapter";
+    export function getAdapter(): Adapter;
+    export function setAdapter(value: Adapter): void;
+    export function asyncStart(): void;
+    export function asyncEnd(): void;
+}

package/external-types/ember-source/types/stable/ember-testing/lib/test/helpers.d.ts

@@ -0,0 +1,116 @@
+declare module 'ember-testing/lib/test/helpers' {
+    import type { AnyFn } from "@ember/-internals/utility-types";
+    import type Application from "@ember/application";
+    export const helpers: Record<string, {
+        method: AnyFn;
+        meta: {
+            wait: boolean;
+        };
+    }>;
+    /**
+     @module @ember/test
+    */
+    /**
+      `registerHelper` is used to register a test helper that will be injected
+      when `App.injectTestHelpers` is called.
+
+      The helper method will always be called with the current Application as
+      the first parameter.
+
+      For example:
+
+      ```javascript
+      import { registerHelper } from '@ember/test';
+      import { run } from '@ember/runloop';
+
+      registerHelper('boot', function(app) {
+        run(app, app.advanceReadiness);
+      });
+      ```
+
+      This helper can later be called without arguments because it will be
+      called with `app` as the first parameter.
+
+      ```javascript
+      import Application from '@ember/application';
+
+      App = Application.create();
+      App.injectTestHelpers();
+      boot();
+      ```
+
+      @public
+      @for @ember/test
+      @static
+      @method registerHelper
+      @param {String} name The name of the helper method to add.
+      @param {Function} helperMethod
+      @param options {Object}
+    */
+    export function registerHelper(name: string, helperMethod: (app: Application, ...args: any[]) => unknown): void;
+    /**
+      `registerAsyncHelper` is used to register an async test helper that will be injected
+      when `App.injectTestHelpers` is called.
+
+      The helper method will always be called with the current Application as
+      the first parameter.
+
+      For example:
+
+      ```javascript
+      import { registerAsyncHelper } from '@ember/test';
+      import { run } from '@ember/runloop';
+
+      registerAsyncHelper('boot', function(app) {
+        run(app, app.advanceReadiness);
+      });
+      ```
+
+      The advantage of an async helper is that it will not run
+      until the last async helper has completed.  All async helpers
+      after it will wait for it complete before running.
+
+
+      For example:
+
+      ```javascript
+      import { registerAsyncHelper } from '@ember/test';
+
+      registerAsyncHelper('deletePost', function(app, postId) {
+        click('.delete-' + postId);
+      });
+
+      // ... in your test
+      visit('/post/2');
+      deletePost(2);
+      visit('/post/3');
+      deletePost(3);
+      ```
+
+      @public
+      @for @ember/test
+      @method registerAsyncHelper
+      @param {String} name The name of the helper method to add.
+      @param {Function} helperMethod
+      @since 1.2.0
+    */
+    export function registerAsyncHelper(name: string, helperMethod: AnyFn): void;
+    /**
+      Remove a previously added helper method.
+
+      Example:
+
+      ```javascript
+      import { unregisterHelper } from '@ember/test';
+
+      unregisterHelper('wait');
+      ```
+
+      @public
+      @method unregisterHelper
+      @static
+      @for @ember/test
+      @param {String} name The helper to remove.
+    */
+    export function unregisterHelper(name: string): void;
+}

package/external-types/ember-source/types/stable/ember-testing/lib/test/on_inject_helpers.d.ts

@@ -0,0 +1,33 @@
+declare module 'ember-testing/lib/test/on_inject_helpers' {
+    import type Application from "@ember/application";
+    export const callbacks: Array<(app: Application) => void>;
+    /**
+      Used to register callbacks to be fired whenever `App.injectTestHelpers`
+      is called.
+
+      The callback will receive the current application as an argument.
+
+      Example:
+
+      ```javascript
+      import $ from 'jquery';
+
+      Ember.Test.onInjectHelpers(function() {
+        $(document).ajaxSend(function() {
+          Test.pendingRequests++;
+        });
+
+        $(document).ajaxComplete(function() {
+          Test.pendingRequests--;
+        });
+      });
+      ```
+
+      @public
+      @for Ember.Test
+      @method onInjectHelpers
+      @param {Function} callback The function to be called.
+    */
+    export function onInjectHelpers(callback: (app: Application) => void): void;
+    export function invokeInjectHelpersCallbacks(app: Application): void;
+}

package/external-types/ember-source/types/stable/ember-testing/lib/test/pending_requests.d.ts

@@ -0,0 +1,6 @@
+declare module 'ember-testing/lib/test/pending_requests' {
+    export function pendingRequests(): number;
+    export function clearPendingRequests(): void;
+    export function incrementPendingRequests(_: unknown, xhr: unknown): void;
+    export function decrementPendingRequests(_: unknown, xhr: unknown): void;
+}

package/external-types/ember-source/types/stable/ember-testing/lib/test/promise.d.ts

@@ -0,0 +1,38 @@
+declare module 'ember-testing/lib/test/promise' {
+    /// <reference types="rsvp" />
+    import { RSVP } from "@ember/-internals/runtime";
+    type Executor<T> = (resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void;
+    type OnFulfilled<T, TResult = T> = (value: T) => TResult | PromiseLike<TResult>;
+    export default class TestPromise<T> extends RSVP.Promise<T> {
+        constructor(executor: Executor<T>, label?: string);
+        then<TResult1 = T, TResult2 = never>(onFulfilled?: OnFulfilled<T, TResult1> | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null, label?: string): RSVP.Promise<TResult1 | TResult2>;
+    }
+    /**
+      This returns a thenable tailored for testing.  It catches failed
+      `onSuccess` callbacks and invokes the `Ember.Test.adapter.exception`
+      callback in the last chained then.
+
+      This method should be returned by async helpers such as `wait`.
+
+      @public
+      @for Ember.Test
+      @method promise
+      @param {Function} resolver The function used to resolve the promise.
+      @param {String} label An optional string for identifying the promise.
+    */
+    export function promise<T>(resolver: Executor<T>, label?: string): TestPromise<T>;
+    /**
+      Replacement for `Ember.RSVP.resolve`
+      The only difference is this uses
+      an instance of `Ember.Test.Promise`
+
+      @public
+      @for Ember.Test
+      @method resolve
+      @param {Mixed} The value to resolve
+      @since 1.2.0
+    */
+    export function resolve(result: unknown, label?: string): RSVP.default.Promise<unknown>;
+    export function getLastPromise(): TestPromise<unknown> | null;
+    export {};
+}

package/external-types/ember-source/types/stable/ember-testing/lib/test/run.d.ts

@@ -0,0 +1,3 @@
+declare module 'ember-testing/lib/test/run' {
+    export default function run<T>(fn: () => T): T;
+}

package/external-types/ember-source/types/stable/ember-testing/lib/test/waiters.d.ts

@@ -0,0 +1,67 @@
+declare module 'ember-testing/lib/test/waiters' {
+    /**
+       This allows ember-testing to play nicely with other asynchronous
+       events, such as an application that is waiting for a CSS3
+       transition or an IndexDB transaction. The waiter runs periodically
+       after each async helper (i.e. `click`, `andThen`, `visit`, etc) has executed,
+       until the returning result is truthy. After the waiters finish, the next async helper
+       is executed and the process repeats.
+
+       For example:
+
+       ```javascript
+       import { registerWaiter } from '@ember/test';
+
+       registerWaiter(function() {
+         return myPendingTransactions() === 0;
+       });
+       ```
+       The `context` argument allows you to optionally specify the `this`
+       with which your callback will be invoked.
+
+       For example:
+
+       ```javascript
+       import { registerWaiter } from '@ember/test';
+
+       registerWaiter(MyDB, MyDB.hasPendingTransactions);
+       ```
+
+       @public
+       @for @ember/test
+       @static
+       @method registerWaiter
+       @param {Object} context (optional)
+       @param {Function} callback
+       @since 1.2.0
+    */
+    export function registerWaiter<T>(context: T, callback: (this: T) => unknown): void;
+    export function registerWaiter(callback: (this: null) => unknown): void;
+    /**
+       `unregisterWaiter` is used to unregister a callback that was
+       registered with `registerWaiter`.
+
+       @public
+       @for @ember/test
+       @static
+       @method unregisterWaiter
+       @param {Object} context (optional)
+       @param {Function} callback
+       @since 1.2.0
+    */
+    export function unregisterWaiter(context: unknown, callback: unknown): void;
+    /**
+      Iterates through each registered test waiter, and invokes
+      its callback. If any waiter returns false, this method will return
+      true indicating that the waiters have not settled yet.
+
+      This is generally used internally from the acceptance/integration test
+      infrastructure.
+
+      @public
+      @for @ember/test
+      @static
+      @method checkWaiters
+    */
+    export function checkWaiters(): boolean;
+}

package/external-types/ember-source/types/stable/ember-testing/lib/test.d.ts

@@ -0,0 +1,47 @@
+declare module 'ember-testing/lib/test' {
+    /**
+      @module ember
+    */
+    import { registerHelper, registerAsyncHelper, unregisterHelper } from "ember-testing/lib/test/helpers";
+    import { onInjectHelpers } from "ember-testing/lib/test/on_inject_helpers";
+    import TestPromise, { promise, resolve } from "ember-testing/lib/test/promise";
+    import { checkWaiters, registerWaiter, unregisterWaiter } from "ember-testing/lib/test/waiters";
+    /**
+      This is a container for an assortment of testing related functionality:
+
+      * Choose your default test adapter (for your framework of choice).
+      * Register/Unregister additional test helpers.
+      * Setup callbacks to be fired when the test helpers are injected into
+        your application.
+
+      @class Test
+      @namespace Ember
+      @public
+    */
+    const Test: {
+        /**
+          Hash containing all known test helpers.
+      
+          @property _helpers
+          @private
+          @since 1.7.0
+        */
+        _helpers: Record<string, {
+            method: import("@ember/-internals/utility-types").AnyFn;
+            meta: {
+                wait: boolean;
+            };
+        }>;
+        registerHelper: typeof registerHelper;
+        registerAsyncHelper: typeof registerAsyncHelper;
+        unregisterHelper: typeof unregisterHelper;
+        onInjectHelpers: typeof onInjectHelpers;
+        Promise: typeof TestPromise;
+        promise: typeof promise;
+        resolve: typeof resolve;
+        registerWaiter: typeof registerWaiter;
+        unregisterWaiter: typeof unregisterWaiter;
+        checkWaiters: typeof checkWaiters;
+    };
+    export default Test;
+}