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

package/types/stable/ember-template-compiler/lib/plugins/transform-action-syntax.d.ts

@@ -0,0 +1,28 @@
+declare module 'ember-template-compiler/lib/plugins/transform-action-syntax.d.ts' {
+  import type { ASTPlugin } from '@glimmer/syntax';
+  import type { EmberASTPluginEnvironment } from '../types';
+  /**
+   @module ember
+  */
+  /**
+    A Glimmer2 AST transformation that replaces all instances of
+
+    ```handlebars
+   <button {{action 'foo'}}>
+   <button onblur={{action 'foo'}}>
+   <button onblur={{action (action 'foo') 'bar'}}>
+    ```
+
+    with
+
+    ```handlebars
+   <button {{action this 'foo'}}>
+   <button onblur={{action this 'foo'}}>
+   <button onblur={{action this (action this 'foo') 'bar'}}>
+    ```
+
+    @private
+    @class TransformActionSyntax
+  */
+  export default function transformActionSyntax({ syntax }: EmberASTPluginEnvironment): ASTPlugin;
+}

package/types/stable/ember-template-compiler/lib/plugins/transform-each-in-into-each.d.ts

@@ -0,0 +1,24 @@
+declare module 'ember-template-compiler/lib/plugins/transform-each-in-into-each.d.ts' {
+  import type { ASTPlugin } from '@glimmer/syntax';
+  import type { EmberASTPluginEnvironment } from '../types';
+  /**
+   @module ember
+  */
+  /**
+    A Glimmer2 AST transformation that replaces all instances of
+
+    ```handlebars
+    {{#each-in iterableThing as |key value|}}
+    ```
+
+    with
+
+    ```handlebars
+    {{#each (-each-in iterableThing) as |value key|}}
+    ```
+
+    @private
+    @class TransformHasBlockSyntax
+  */
+  export default function transformEachInIntoEach(env: EmberASTPluginEnvironment): ASTPlugin;
+}

package/types/stable/ember-template-compiler/lib/plugins/transform-each-track-array.d.ts

@@ -0,0 +1,24 @@
+declare module 'ember-template-compiler/lib/plugins/transform-each-track-array.d.ts' {
+  import type { ASTPlugin } from '@glimmer/syntax';
+  import type { EmberASTPluginEnvironment } from '../types';
+  /**
+   @module ember
+  */
+  /**
+    A Glimmer2 AST transformation that replaces all instances of
+
+    ```handlebars
+    {{#each iterableThing as |key value|}}
+    ```
+
+    with
+
+    ```handlebars
+    {{#each (-track-array iterableThing) as |key value|}}
+    ```
+
+    @private
+    @class TransformHasBlockSyntax
+  */
+  export default function transformEachTrackArray(env: EmberASTPluginEnvironment): ASTPlugin;
+}

package/types/stable/ember-template-compiler/lib/plugins/transform-in-element.d.ts

@@ -0,0 +1,22 @@
+declare module 'ember-template-compiler/lib/plugins/transform-in-element.d.ts' {
+  import type { ASTPlugin } from '@glimmer/syntax';
+  import type { EmberASTPluginEnvironment } from '../types';
+  /**
+   @module ember
+  */
+  /**
+    A Glimmer2 AST transformation that handles the public `{{in-element}}` as per RFC287.
+
+    Issues a build time assertion for:
+
+    ```handlebars
+    {{#in-element someElement insertBefore="some-none-null-value"}}
+      {{modal-display text=text}}
+    {{/in-element}}
+    ```
+
+    @private
+    @class TransformInElement
+  */
+  export default function transformInElement(env: EmberASTPluginEnvironment): ASTPlugin;
+}

package/types/stable/ember-template-compiler/lib/plugins/transform-quoted-bindings-into-just-bindings.d.ts

@@ -0,0 +1,4 @@
+declare module 'ember-template-compiler/lib/plugins/transform-quoted-bindings-into-just-bindings.d.ts' {
+  import type { ASTPlugin } from '@glimmer/syntax';
+  export default function transformQuotedBindingsIntoJustBindings(): ASTPlugin;
+}

package/types/stable/ember-template-compiler/lib/plugins/transform-resolutions.d.ts

@@ -0,0 +1,5 @@
+declare module 'ember-template-compiler/lib/plugins/transform-resolutions.d.ts' {
+  import type { ASTPlugin } from '@glimmer/syntax';
+  import type { EmberASTPluginEnvironment } from '../types';
+  export default function transformResolutions(env: EmberASTPluginEnvironment): ASTPlugin;
+}

package/types/stable/ember-template-compiler/lib/plugins/transform-wrap-mount-and-outlet.d.ts

@@ -0,0 +1,36 @@
+declare module 'ember-template-compiler/lib/plugins/transform-wrap-mount-and-outlet.d.ts' {
+  import type { ASTPlugin } from '@glimmer/syntax';
+  import type { EmberASTPluginEnvironment } from '../types';
+  /**
+   @module ember
+  */
+  /**
+    A Glimmer2 AST transformation that replaces all instances of
+
+    ```handlebars
+    {{mount "engine" model=this.model}}
+    ```
+
+    with
+
+    ```handlebars
+    {{component (-mount "engine" model=this.model)}}
+    ```
+
+    and
+
+    ```handlebars
+    {{outlet}}
+    ```
+
+    with
+
+    ```handlebars
+    {{component (-outlet)}}
+    ```
+
+    @private
+    @class TransformHasBlockSyntax
+  */
+  export default function transformWrapMountAndOutlet(env: EmberASTPluginEnvironment): ASTPlugin;
+}

package/types/stable/ember-template-compiler/lib/plugins/utils.d.ts

@@ -0,0 +1,13 @@
+declare module 'ember-template-compiler/lib/plugins/utils.d.ts' {
+  import type { AST } from '@glimmer/syntax';
+  export function isPath(node: AST.Node): node is AST.PathExpression;
+  export function isSubExpression(node: AST.Node): node is AST.SubExpression;
+  export function isStringLiteral(node: AST.Expression): node is AST.StringLiteral;
+  export function trackLocals(): {
+      hasLocal: (key: string) => boolean;
+      node: {
+          enter(node: AST.Program | AST.Block | AST.ElementNode): void;
+          exit(node: AST.Program | AST.Block | AST.ElementNode): void;
+      };
+  };
+}

package/types/stable/ember-template-compiler/lib/system/bootstrap.d.ts

@@ -0,0 +1,26 @@
+declare module 'ember-template-compiler/lib/system/bootstrap.d.ts' {
+  /**
+  @module ember
+  */
+  import type { TemplateFactory } from '@glimmer/interfaces';
+  export interface BootstrapOptions {
+      context?: Document | HTMLElement;
+      hasTemplate(templateName: string): boolean;
+      setTemplate(templateName: string, template: TemplateFactory): void;
+  }
+  /**
+    Find templates stored in the head tag as script tags and make them available
+    to `Ember.CoreView` in the global `Ember.TEMPLATES` object.
+
+    Script tags with `text/x-handlebars` will be compiled
+    with Ember's template compiler and are suitable for use as a view's template.
+
+    @private
+    @method bootstrap
+    @for Ember.HTMLBars
+    @static
+    @param ctx
+  */
+  function bootstrap({ context, hasTemplate, setTemplate }: BootstrapOptions): void;
+  export default bootstrap;
+}

package/types/stable/ember-template-compiler/lib/system/calculate-location-display.d.ts

@@ -0,0 +1,4 @@
+declare module 'ember-template-compiler/lib/system/calculate-location-display.d.ts' {
+  import type { AST } from '@glimmer/syntax';
+  export default function calculateLocationDisplay(moduleName: string | undefined, loc?: AST.SourceLocation | undefined): string;
+}

package/types/stable/ember-template-compiler/lib/system/compile-options.d.ts

@@ -0,0 +1,6 @@
+declare module 'ember-template-compiler/lib/system/compile-options.d.ts' {
+  import type { EmberPrecompileOptions, PluginFunc } from '../types';
+  export function buildCompileOptions(_options: EmberPrecompileOptions): EmberPrecompileOptions;
+  export function transformsFor(options: EmberPrecompileOptions): readonly PluginFunc[];
+  export default function compileOptions(_options?: Partial<EmberPrecompileOptions>): EmberPrecompileOptions;
+}

package/types/stable/ember-template-compiler/lib/system/compile.d.ts

@@ -0,0 +1,13 @@
+declare module 'ember-template-compiler/lib/system/compile.d.ts' {
+  import type { EmberPrecompileOptions } from '../types';
+  import type { TemplateFactory } from '@glimmer/interfaces';
+  /**
+    Uses HTMLBars `compile` function to process a string into a compiled template.
+    This is not present in production builds.
+    @private
+    @method compile
+    @param {String} templateString This is the string to be compiled by HTMLBars.
+    @param {Object} options This is an options hash to augment the compiler options.
+  */
+  export default function compile(templateString: string, options?: Partial<EmberPrecompileOptions>): TemplateFactory;
+}

package/types/stable/ember-template-compiler/lib/system/dasherize-component-name.d.ts

@@ -0,0 +1,5 @@
+declare module 'ember-template-compiler/lib/system/dasherize-component-name.d.ts' {
+  import { Cache } from '@ember/-internals/utils';
+  const _default: Cache<string, string>;
+  export default _default;
+}

package/types/stable/ember-template-compiler/lib/system/initializer.d.ts

@@ -0,0 +1,3 @@
+declare module 'ember-template-compiler/lib/system/initializer.d.ts' {
+  export {};
+}

package/types/stable/ember-template-compiler/lib/system/precompile.d.ts

@@ -0,0 +1,17 @@
+declare module 'ember-template-compiler/lib/system/precompile.d.ts' {
+  /**
+  @module ember
+  */
+  import type { EmberPrecompileOptions } from '../types';
+  /**
+    Uses HTMLBars `compile` function to process a string into a compiled template string.
+    The returned string must be passed through `Ember.HTMLBars.template`.
+
+    This is not present in production builds.
+
+    @private
+    @method precompile
+    @param {String} templateString This is the string to be compiled by HTMLBars.
+  */
+  export default function precompile(templateString: string, options?: Partial<EmberPrecompileOptions>): string;
+}

package/types/stable/ember-testing/index.d.ts

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

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

@@ -0,0 +1,20 @@
+declare module 'ember-testing/lib/adapters/adapter.d.ts' {
+  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);
+  export default Adapter;
+}

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

@@ -0,0 +1,19 @@
+declare module 'ember-testing/lib/adapters/qunit.d.ts' {
+  import Adapter from './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 {
+  }
+  const QUnitAdapter: Readonly<Readonly<typeof import("../../../@ember/object").default> & (new (owner?: import("../../../@ember/owner").default | undefined) => import("../../../@ember/object").default)> & (new (owner?: import("../../../@ember/owner").default | undefined) => import("../../../@ember/object").default);
+  export default QUnitAdapter;
+}

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

@@ -0,0 +1,12 @@
+declare module 'ember-testing/lib/ext/application.d.ts' {
+  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/types/stable/ember-testing/lib/ext/rsvp.d.ts

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

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

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

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

@@ -0,0 +1,22 @@
+declare module 'ember-testing/lib/helpers/current_path.d.ts' {
+  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/types/stable/ember-testing/lib/helpers/current_route_name.d.ts

@@ -0,0 +1,21 @@
+declare module 'ember-testing/lib/helpers/current_route_name.d.ts' {
+  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/types/stable/ember-testing/lib/helpers/current_url.d.ts

@@ -0,0 +1,22 @@
+declare module 'ember-testing/lib/helpers/current_url.d.ts' {
+  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/types/stable/ember-testing/lib/helpers/pause_test.d.ts

@@ -0,0 +1,53 @@
+declare module 'ember-testing/lib/helpers/pause_test.d.ts' {
+  /// <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/types/stable/ember-testing/lib/helpers/visit.d.ts

@@ -0,0 +1,22 @@
+declare module 'ember-testing/lib/helpers/visit.d.ts' {
+  import type { TestableApp } from '../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/types/stable/ember-testing/lib/helpers/wait.d.ts

@@ -0,0 +1,34 @@
+declare module 'ember-testing/lib/helpers/wait.d.ts' {
+  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/types/stable/ember-testing/lib/helpers.d.ts

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

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

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

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

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

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

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

@@ -0,0 +1,115 @@
+declare module 'ember-testing/lib/test/helpers.d.ts' {
+  import type { AnyFn } from '@ember/-internals/utility-types';
+  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: AnyFn): 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;
+}