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

package/types/stable/@ember/service/index.d.ts

@@ -0,0 +1,82 @@
+declare module '@ember/service' {
+  import { FrameworkObject } from '@ember/object/-internals';
+  import type { DecoratorPropertyDescriptor, ElementDescriptor } from '@ember/-internals/metal';
+  /**
+   @module @ember/service
+   @public
+   */
+  /**
+    @method inject
+    @static
+    @since 1.10.0
+    @for @ember/service
+    @param {String} name (optional) name of the service to inject, defaults to
+           the property's name
+    @return {ComputedDecorator} injection decorator instance
+    @public
+  */
+  export function inject(name: string): PropertyDecorator;
+  export function inject(...args: [ElementDescriptor[0], ElementDescriptor[1]]): void;
+  export function inject(...args: ElementDescriptor): DecoratorPropertyDescriptor;
+  export function inject(): PropertyDecorator;
+  /**
+    Creates a property that lazily looks up a service in the container. There are
+    no restrictions as to what objects a service can be injected into.
+
+    Example:
+
+    ```app/routes/application.js
+    import Route from '@ember/routing/route';
+    import { service } from '@ember/service';
+
+    export default class ApplicationRoute extends Route {
+      @service('auth') authManager;
+
+      model() {
+        return this.authManager.findCurrentUser();
+      }
+    }
+    ```
+
+    Classic Class Example:
+
+    ```app/routes/application.js
+    import Route from '@ember/routing/route';
+    import { service } from '@ember/service';
+
+    export default Route.extend({
+      authManager: service('auth'),
+
+      model() {
+        return this.get('authManager').findCurrentUser();
+      }
+    });
+    ```
+
+    This example will create an `authManager` property on the application route
+    that looks up the `auth` service in the container, making it easily accessible
+    in the `model` hook.
+
+    @method service
+    @static
+    @since 4.1.0
+    @for @ember/service
+    @param {String} name (optional) name of the service to inject, defaults to
+           the property's name
+    @return {ComputedDecorator} injection decorator instance
+    @public
+  */
+  export function service(name: string): PropertyDecorator;
+  export function service(...args: [ElementDescriptor[0], ElementDescriptor[1]]): void;
+  export function service(...args: ElementDescriptor): DecoratorPropertyDescriptor;
+  export function service(): PropertyDecorator;
+  /**
+    @class Service
+    @extends EmberObject
+    @since 1.10.0
+    @public
+  */
+  export default class Service extends FrameworkObject {
+      static isServiceFactory: boolean;
+  }
+}

package/types/stable/@ember/string/index.d.ts

@@ -0,0 +1,152 @@
+declare module '@ember/string' {
+  /**
+  @module @ember/string
+  */
+  export { getStrings as _getStrings, setStrings as _setStrings } from './lib/string_registry';
+  import type { SafeString } from '@ember/-internals/glimmer';
+  /**
+    Defines string helper methods including string formatting and localization.
+
+    @class String
+    @public
+  */
+  /**
+    Splits a string into separate units separated by spaces, eliminating any
+    empty strings in the process.
+
+    ```javascript
+    import { w } from '@ember/string';
+
+    w("alpha beta gamma").forEach(function(key) {
+      console.log(key);
+    });
+
+    // > alpha
+    // > beta
+    // > gamma
+    ```
+
+    @method w
+    @param {String} str The string to split
+    @return {Array} array containing the split strings
+    @public
+  */
+  export function w(str: string): string[];
+  /**
+    Converts a camelized string into all lower case separated by underscores.
+
+    ```javascript
+    import { decamelize } from '@ember/string';
+
+    decamelize('innerHTML');          // 'inner_html'
+    decamelize('action_name');        // 'action_name'
+    decamelize('css-class-name');     // 'css-class-name'
+    decamelize('my favorite items');  // 'my favorite items'
+    ```
+
+    @method decamelize
+    @param {String} str The string to decamelize.
+    @return {String} the decamelized string.
+    @public
+  */
+  export function decamelize(str: string): string;
+  /**
+    Replaces underscores, spaces, or camelCase with dashes.
+
+    ```javascript
+    import { dasherize } from '@ember/string';
+
+    dasherize('innerHTML');                // 'inner-html'
+    dasherize('action_name');              // 'action-name'
+    dasherize('css-class-name');           // 'css-class-name'
+    dasherize('my favorite items');        // 'my-favorite-items'
+    dasherize('privateDocs/ownerInvoice';  // 'private-docs/owner-invoice'
+    ```
+
+    @method dasherize
+    @param {String} str The string to dasherize.
+    @return {String} the dasherized string.
+    @public
+  */
+  export function dasherize(str: string): string;
+  /**
+    Returns the lowerCamelCase form of a string.
+
+    ```javascript
+    import { camelize } from '@ember/string';
+
+    camelize('innerHTML');                   // 'innerHTML'
+    camelize('action_name');                 // 'actionName'
+    camelize('css-class-name');              // 'cssClassName'
+    camelize('my favorite items');           // 'myFavoriteItems'
+    camelize('My Favorite Items');           // 'myFavoriteItems'
+    camelize('private-docs/owner-invoice');  // 'privateDocs/ownerInvoice'
+    ```
+
+    @method camelize
+    @param {String} str The string to camelize.
+    @return {String} the camelized string.
+    @public
+  */
+  export function camelize(str: string): string;
+  /**
+    Returns the UpperCamelCase form of a string.
+
+    ```javascript
+    import { classify } from '@ember/string';
+
+    classify('innerHTML');                   // 'InnerHTML'
+    classify('action_name');                 // 'ActionName'
+    classify('css-class-name');              // 'CssClassName'
+    classify('my favorite items');           // 'MyFavoriteItems'
+    classify('private-docs/owner-invoice');  // 'PrivateDocs/OwnerInvoice'
+    ```
+
+    @method classify
+    @param {String} str the string to classify
+    @return {String} the classified string
+    @public
+  */
+  export function classify(str: string): string;
+  /**
+    More general than decamelize. Returns the lower\_case\_and\_underscored
+    form of a string.
+
+    ```javascript
+    import { underscore } from '@ember/string';
+
+    underscore('innerHTML');                 // 'inner_html'
+    underscore('action_name');               // 'action_name'
+    underscore('css-class-name');            // 'css_class_name'
+    underscore('my favorite items');         // 'my_favorite_items'
+    underscore('privateDocs/ownerInvoice');  // 'private_docs/owner_invoice'
+    ```
+
+    @method underscore
+    @param {String} str The string to underscore.
+    @return {String} the underscored string.
+    @public
+  */
+  export function underscore(str: string): string;
+  /**
+    Returns the Capitalized form of a string
+
+    ```javascript
+    import { capitalize } from '@ember/string';
+
+    capitalize('innerHTML')                 // 'InnerHTML'
+    capitalize('action_name')               // 'Action_name'
+    capitalize('css-class-name')            // 'Css-class-name'
+    capitalize('my favorite items')         // 'My favorite items'
+    capitalize('privateDocs/ownerInvoice'); // 'PrivateDocs/ownerInvoice'
+    ```
+
+    @method capitalize
+    @param {String} str The string to capitalize.
+    @return {String} The capitalized string.
+    @public
+  */
+  export function capitalize(str: string): string;
+  export function htmlSafe(str: string): SafeString;
+  export function isHTMLSafe(str: any | null | undefined): str is SafeString;
+}

package/types/stable/@ember/string/lib/string_registry.d.ts

@@ -0,0 +1,9 @@
+declare module '@ember/string/lib/string_registry.d.ts' {
+  export function setStrings(strings: {
+      [key: string]: string;
+  }): void;
+  export function getStrings(): {
+      [key: string]: string;
+  };
+  export function getString(name: string): string | undefined;
+}

package/types/stable/@ember/template/index.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/template' {
+  export { htmlSafe, isHTMLSafe } from '@ember/-internals/glimmer';
+}

package/types/stable/@ember/template-compilation/index.d.ts

@@ -0,0 +1,4 @@
+declare module '@ember/template-compilation' {
+  export { compile as compileTemplate } from 'ember-template-compiler';
+  export let precompileTemplate: (() => never) | undefined;
+}

package/types/stable/@ember/template-factory/index.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/template-factory' {
+  export { templateFactory as createTemplateFactory } from '@glimmer/opcode-compiler';
+}

package/types/stable/@ember/test/adapter.d.ts

@@ -0,0 +1,4 @@
+declare module '@ember/test/adapter.d.ts' {
+  import { Adapter } from 'ember-testing';
+  export default Adapter;
+}

package/types/stable/@ember/test/index.d.ts

@@ -0,0 +1,8 @@
+declare module '@ember/test' {
+  import { type Test } from 'ember-testing';
+  export let registerAsyncHelper: typeof Test['registerAsyncHelper'] | (() => never);
+  export let registerHelper: typeof Test['registerHelper'] | (() => never);
+  export let registerWaiter: typeof Test['registerWaiter'] | (() => never);
+  export let unregisterHelper: typeof Test['unregisterHelper'] | (() => never);
+  export let unregisterWaiter: typeof Test['unregisterWaiter'] | (() => never);
+}

package/types/stable/@ember/utils/index.d.ts

@@ -0,0 +1,9 @@
+declare module '@ember/utils' {
+  export { default as isNone } from './lib/is_none';
+  export { default as isBlank } from './lib/is_blank';
+  export { default as isEmpty } from './lib/is_empty';
+  export { default as isPresent } from './lib/is_present';
+  export { default as isEqual } from './lib/is-equal';
+  export { default as typeOf } from './lib/type-of';
+  export { default as compare } from './lib/compare';
+}

package/types/stable/@ember/utils/lib/compare.d.ts

@@ -0,0 +1,54 @@
+declare module '@ember/utils/lib/compare.d.ts' {
+  type Compare = -1 | 0 | 1;
+  /**
+   @module @ember/utils
+  */
+  /**
+   Compares two javascript values and returns:
+
+    - -1 if the first is smaller than the second,
+    - 0 if both are equal,
+    - 1 if the first is greater than the second.
+
+    ```javascript
+    import { compare } from '@ember/utils';
+
+    compare('hello', 'hello');  // 0
+    compare('abc', 'dfg');      // -1
+    compare(2, 1);              // 1
+    ```
+
+   If the types of the two objects are different precedence occurs in the
+   following order, with types earlier in the list considered `<` types
+   later in the list:
+
+    - undefined
+    - null
+    - boolean
+    - number
+    - string
+    - array
+    - object
+    - instance
+    - function
+    - class
+    - date
+
+    ```javascript
+    import { compare } from '@ember/utils';
+
+    compare('hello', 50);       // 1
+    compare(50, 'hello');       // -1
+    ```
+
+   @method compare
+   @for @ember/utils
+   @static
+   @param {Object} v First value to compare
+   @param {Object} w Second value to compare
+   @return {Number} -1 if v < w, 0 if v = w and 1 if v > w.
+   @public
+  */
+  export default function compare(v: unknown, w: unknown): Compare;
+  export {};
+}

package/types/stable/@ember/utils/lib/is-equal.d.ts

@@ -0,0 +1,52 @@
+declare module '@ember/utils/lib/is-equal.d.ts' {
+  /**
+   @module @ember/utils
+  */
+  /**
+    Compares two objects, returning true if they are equal.
+
+    ```javascript
+    import { isEqual } from '@ember/utils';
+
+    isEqual('hello', 'hello');                   // true
+    isEqual(1, 2);                               // false
+    ```
+
+    `isEqual` is a more specific comparison than a triple equal comparison.
+    It will call the `isEqual` instance method on the objects being
+    compared, allowing finer control over when objects should be considered
+    equal to each other.
+
+    ```javascript
+    import { isEqual } from '@ember/utils';
+    import EmberObject from '@ember/object';
+
+    let Person = EmberObject.extend({
+      isEqual(other) { return this.ssn == other.ssn; }
+    });
+
+    let personA = Person.create({name: 'Muhammad Ali', ssn: '123-45-6789'});
+    let personB = Person.create({name: 'Cassius Clay', ssn: '123-45-6789'});
+
+    isEqual(personA, personB); // true
+    ```
+
+    Due to the expense of array comparisons, collections will never be equal to
+    each other even if each of their items are equal to each other.
+
+    ```javascript
+    import { isEqual } from '@ember/utils';
+
+    isEqual([4, 2], [4, 2]);                     // false
+    ```
+
+    @method isEqual
+    @for @ember/utils
+    @static
+    @param {Object} a first object to compare
+    @param {Object} b second object to compare
+    @return {Boolean}
+    @public
+  */
+  export default function isEqual(a: unknown, b: unknown): boolean;
+}

package/types/stable/@ember/utils/lib/is_blank.d.ts

@@ -0,0 +1,32 @@
+declare module '@ember/utils/lib/is_blank.d.ts' {
+  /**
+   @module @ember/utils
+  */
+  /**
+    A value is blank if it is empty or a whitespace string.
+
+    ```javascript
+    import { isBlank } from '@ember/utils';
+
+    isBlank(null);            // true
+    isBlank(undefined);       // true
+    isBlank('');              // true
+    isBlank([]);              // true
+    isBlank('\n\t');          // true
+    isBlank('  ');            // true
+    isBlank({});              // false
+    isBlank('\n\t Hello');    // false
+    isBlank('Hello world');   // false
+    isBlank([1,2,3]);         // false
+    ```
+
+    @method isBlank
+    @static
+    @for @ember/utils
+    @param {Object} obj Value to test
+    @return {Boolean}
+    @since 1.5.0
+    @public
+  */
+  export default function isBlank(obj: unknown): boolean;
+}

package/types/stable/@ember/utils/lib/is_empty.d.ts

@@ -0,0 +1,38 @@
+declare module '@ember/utils/lib/is_empty.d.ts' {
+  /**
+   @module @ember/utils
+  */
+  /**
+    Verifies that a value is `null` or `undefined`, an empty string, or an empty
+    array.
+
+    Constrains the rules on `isNone` by returning true for empty strings and
+    empty arrays.
+
+    If the value is an object with a `size` property of type number, it is used
+    to check emptiness.
+
+    ```javascript
+    isEmpty(null);             // true
+    isEmpty(undefined);        // true
+    isEmpty('');               // true
+    isEmpty([]);               // true
+    isEmpty({ size: 0});       // true
+    isEmpty({});               // false
+    isEmpty('Adam Hawkins');   // false
+    isEmpty([0,1,2]);          // false
+    isEmpty('\n\t');           // false
+    isEmpty('  ');             // false
+    isEmpty({ size: 1 })       // false
+    isEmpty({ size: () => 0 }) // false
+    ```
+
+    @method isEmpty
+    @static
+    @for @ember/utils
+    @param {Object} obj Value to test
+    @return {Boolean}
+    @public
+  */
+  export default function isEmpty(obj: unknown): boolean;
+}

package/types/stable/@ember/utils/lib/is_none.d.ts

@@ -0,0 +1,26 @@
+declare module '@ember/utils/lib/is_none.d.ts' {
+  /**
+   @module @ember/utils
+  */
+  /**
+    Returns true if the passed value is null or undefined. This avoids errors
+    from JSLint complaining about use of ==, which can be technically
+    confusing.
+
+    ```javascript
+    isNone(null);          // true
+    isNone(undefined);     // true
+    isNone('');            // false
+    isNone([]);            // false
+    isNone(function() {}); // false
+    ```
+
+    @method isNone
+    @static
+    @for @ember/utils
+    @param {Object} obj Value to test
+    @return {Boolean}
+    @public
+  */
+  export default function isNone(obj: any): obj is null | undefined;
+}

package/types/stable/@ember/utils/lib/is_present.d.ts

@@ -0,0 +1,35 @@
+declare module '@ember/utils/lib/is_present.d.ts' {
+  /**
+   @module @ember/utils
+  */
+  /**
+    A value is present if it not `isBlank`.
+
+    ```javascript
+    isPresent(null);            // false
+    isPresent(undefined);       // false
+    isPresent('');              // false
+    isPresent('  ');            // false
+    isPresent('\n\t');          // false
+    isPresent([]);              // false
+    isPresent({ length: 0 });   // false
+    isPresent(false);           // true
+    isPresent(true);            // true
+    isPresent('string');        // true
+    isPresent(0);               // true
+    isPresent(function() {});   // true
+    isPresent({});              // true
+    isPresent('\n\t Hello');    // true
+    isPresent([1, 2, 3]);       // true
+    ```
+
+    @method isPresent
+    @static
+    @for @ember/utils
+    @param {Object} obj Value to test
+    @return {Boolean}
+    @since 1.8.0
+    @public
+  */
+  export default function isPresent<T>(obj: T | null | undefined): obj is T;
+}

package/types/stable/@ember/utils/lib/type-of.d.ts

@@ -0,0 +1,68 @@
+declare module '@ember/utils/lib/type-of.d.ts' {
+  export type TypeName = 'undefined' | 'null' | 'string' | 'number' | 'boolean' | 'function' | 'array' | 'regexp' | 'date' | 'filelist' | 'class' | 'instance' | 'error' | 'object';
+  /**
+   @module @ember/utils
+  */
+  /**
+    Returns a consistent type for the passed object.
+
+    Use this instead of the built-in `typeof` to get the type of an item.
+    It will return the same result across all browsers and includes a bit
+    more detail. Here is what will be returned:
+
+        | Return Value  | Meaning                                              |
+        |---------------|------------------------------------------------------|
+        | 'string'      | String primitive or String object.                   |
+        | 'number'      | Number primitive or Number object.                   |
+        | 'boolean'     | Boolean primitive or Boolean object.                 |
+        | 'null'        | Null value                                           |
+        | 'undefined'   | Undefined value                                      |
+        | 'function'    | A function                                           |
+        | 'array'       | An instance of Array                                 |
+        | 'regexp'      | An instance of RegExp                                |
+        | 'date'        | An instance of Date                                  |
+        | 'filelist'    | An instance of FileList                              |
+        | 'class'       | An Ember class (created using EmberObject.extend())  |
+        | 'instance'    | An Ember object instance                             |
+        | 'error'       | An instance of the Error object                      |
+        | 'object'      | A JavaScript object not inheriting from EmberObject  |
+
+    Examples:
+
+    ```javascript
+    import { A } from '@ember/array';
+    import { typeOf } from '@ember/utils';
+    import EmberObject from '@ember/object';
+
+    typeOf();                       // 'undefined'
+    typeOf(null);                   // 'null'
+    typeOf(undefined);              // 'undefined'
+    typeOf('michael');              // 'string'
+    typeOf(new String('michael'));  // 'string'
+    typeOf(101);                    // 'number'
+    typeOf(new Number(101));        // 'number'
+    typeOf(true);                   // 'boolean'
+    typeOf(new Boolean(true));      // 'boolean'
+    typeOf(A);                      // 'function'
+    typeOf(A());                    // 'array'
+    typeOf([1, 2, 90]);             // 'array'
+    typeOf(/abc/);                  // 'regexp'
+    typeOf(new Date());             // 'date'
+    typeOf(event.target.files);     // 'filelist'
+    typeOf(EmberObject.extend());   // 'class'
+    typeOf(EmberObject.create());   // 'instance'
+    typeOf(new Error('teamocil'));  // 'error'
+
+    // 'normal' JavaScript object
+    typeOf({ a: 'b' });             // 'object'
+    ```
+
+    @method typeOf
+    @for @ember/utils
+    @param item the item to check
+    @return {String} the type
+    @public
+    @static
+  */
+  export default function typeOf(item: unknown): TypeName;
+}

package/types/stable/@ember/version/index.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/version' {
+  export { default as VERSION } from 'ember/version';
+}