npm - ember-source - Versions diffs - 4.10.0-beta.2 → 4.11.0-alpha.2 - Mend

ember-source 4.10.0-beta.2 → 4.11.0-alpha.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (361) hide show

package/types/stable/ember-testing/lib/test/on_inject_helpers.d.ts ADDED Viewed

@@ -0,0 +1,33 @@
+declare module 'ember-testing/lib/test/on_inject_helpers.d.ts' {
+  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/types/stable/ember-testing/lib/test/pending_requests.d.ts ADDED Viewed

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

package/types/stable/ember-testing/lib/test/promise.d.ts ADDED Viewed

@@ -0,0 +1,38 @@
+declare module 'ember-testing/lib/test/promise.d.ts' {
+  /// <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/types/stable/ember-testing/lib/test/run.d.ts ADDED Viewed

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

package/types/stable/ember-testing/lib/test/waiters.d.ts ADDED Viewed

@@ -0,0 +1,67 @@
+declare module 'ember-testing/lib/test/waiters.d.ts' {
+  /**
+     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/types/stable/ember-testing/lib/test.d.ts ADDED Viewed

@@ -0,0 +1,47 @@
+declare module 'ember-testing/lib/test.d.ts' {
+  /**
+    @module ember
+  */
+  import { registerHelper, registerAsyncHelper, unregisterHelper } from './test/helpers';
+  import { onInjectHelpers } from './test/on_inject_helpers';
+  import TestPromise, { promise, resolve } from './test/promise';
+  import { checkWaiters, registerWaiter, unregisterWaiter } from './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;
+}

package/types/stable/index.d.ts ADDED Viewed

@@ -0,0 +1,47 @@
+/**
+  *Provides **stable** type definitions for Ember.js.*
+  This module is generated automatically as part of Ember's publishing process and
+  should never be edited manually.
+  To use these type definitions, add this import to any TypeScript file in your
+  Ember app or addon:
+  ```ts
+  import 'ember-source/types';
+  import 'ember-source/types/preview';
+  ```
+  @module
+ */
+// This works because each of these modules presents `declare module` definition
+// of the module and *only* that, so importing this file in turn makes those
+// module declarations "visible" automatically throughout a consuming project.
+// Combined with use of `typesVersions` (or, in the future, possibly `exports`)
+// in `package.json`, this allows users to import the types without knowing the
+// exact layout details.
+//
+// Somewhat annoyingly, every single module in the graph must appear here. For
+// now, while we are publishing ambient types, that means we must maintain this
+// by hand. When we start emitting types from the source, we will need to do the
+// same work, but automatically.
+// STATUS NOTE: this does not yet include Ember's full public API, only the
+// subset of it for which we have determined the types are ready to stabilize.
+//
+// Over time, it will come to include *all* of Ember's types, and the matching
+// `preview` types will become empty. This is means that someone who writes the
+// import we recommend--
+//
+// ```ts
+// import 'ember-source/types';
+// import 'ember-source/types/preview';
+// ```
+//
+// --will always get the most up-to-date mix of preview and stable types, with
+// no extra effort required.
+import './@ember/-internals/owner';
+import './@ember/-internals/utility-types';
+import './@ember/owner';