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

package/types/stable/@ember/-internals/metal/lib/expand_properties.d.ts

@@ -0,0 +1,33 @@
+declare module '@ember/-internals/metal/lib/expand_properties.d.ts' {
+  /**
+    Expands `pattern`, invoking `callback` for each expansion.
+
+    The only pattern supported is brace-expansion, anything else will be passed
+    once to `callback` directly.
+
+    Example
+
+    ```js
+    import { expandProperties } from '@ember/object/computed';
+
+    function echo(arg){ console.log(arg); }
+
+    expandProperties('foo.bar', echo);              //=> 'foo.bar'
+    expandProperties('{foo,bar}', echo);            //=> 'foo', 'bar'
+    expandProperties('foo.{bar,baz}', echo);        //=> 'foo.bar', 'foo.baz'
+    expandProperties('{foo,bar}.baz', echo);        //=> 'foo.baz', 'bar.baz'
+    expandProperties('foo.{bar,baz}.[]', echo)      //=> 'foo.bar.[]', 'foo.baz.[]'
+    expandProperties('{foo,bar}.{spam,eggs}', echo) //=> 'foo.spam', 'foo.eggs', 'bar.spam', 'bar.eggs'
+    expandProperties('{foo}.bar.{baz}')             //=> 'foo.bar.baz'
+    ```
+
+    @method expandProperties
+    @static
+    @for @ember/object/computed
+    @public
+    @param {String} pattern The property pattern to expand.
+    @param {Function} callback The callback to invoke.  It is invoked once per
+    expansion, and is passed the expansion.
+  */
+  export default function expandProperties(pattern: string, callback: (expansion: string) => void): void;
+}

package/types/stable/@ember/-internals/metal/lib/get_properties.d.ts

@@ -0,0 +1,36 @@
+declare module '@ember/-internals/metal/lib/get_properties.d.ts' {
+  /**
+   @module @ember/object
+  */
+  /**
+    To get multiple properties at once, call `getProperties`
+    with an object followed by a list of strings or an array:
+
+    ```javascript
+    import { getProperties } from '@ember/object';
+
+    getProperties(record, 'firstName', 'lastName', 'zipCode');
+    // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
+    ```
+
+    is equivalent to:
+
+    ```javascript
+    import { getProperties } from '@ember/object';
+
+    getProperties(record, ['firstName', 'lastName', 'zipCode']);
+    // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
+    ```
+
+    @method getProperties
+    @static
+    @for @ember/object
+    @param {Object} obj
+    @param {String...|Array} list of keys to get
+    @return {Object}
+    @public
+  */
+  function getProperties<L extends string[]>(obj: unknown, list: L): Record<L[number], unknown>;
+  function getProperties<L extends string[]>(obj: unknown, ...list: L): Record<L[number], unknown>;
+  export default getProperties;
+}

package/types/stable/@ember/-internals/metal/lib/injected_property.d.ts

@@ -0,0 +1,25 @@
+declare module '@ember/-internals/metal/lib/injected_property.d.ts' {
+  import type { DecoratorPropertyDescriptor, ElementDescriptor } from './decorator';
+  export let DEBUG_INJECTION_FUNCTIONS: WeakMap<Function, any>;
+  /**
+   @module ember
+   @private
+   */
+  /**
+    Read-only property that returns the result of a container lookup.
+
+    @class InjectedProperty
+    @namespace Ember
+    @constructor
+    @param {String} type The container type the property will lookup
+    @param {String} nameOrDesc (optional) The name the property will lookup, defaults
+           to the property's name
+    @private
+  */
+  function inject(type: string, name: string): PropertyDecorator;
+  function inject(type: string): PropertyDecorator;
+  function inject(type: string, ...args: [ElementDescriptor[0], ElementDescriptor[1]]): void;
+  function inject(type: string, ...args: ElementDescriptor): DecoratorPropertyDescriptor;
+  function inject(type: string, ...args: [] | [name: string] | ElementDescriptor): PropertyDecorator | DecoratorPropertyDescriptor | void;
+  export default inject;
+}

package/types/stable/@ember/-internals/metal/lib/libraries.d.ts

@@ -0,0 +1,31 @@
+declare module '@ember/-internals/metal/lib/libraries.d.ts' {
+  interface Library {
+      readonly name: string;
+      readonly version: string;
+  }
+  /**
+   @module ember
+  */
+  /**
+    Helper class that allows you to register your library with Ember.
+
+    Singleton created at `Ember.libraries`.
+
+    @class Libraries
+    @constructor
+    @private
+  */
+  export class Libraries {
+      readonly _registry: Library[];
+      _coreLibIndex: number;
+      constructor();
+      _getLibraryByName(name: string): Library | undefined;
+      register(name: string, version: string, isCoreLibrary?: boolean): void;
+      registerCoreLibrary(name: string, version: string): void;
+      deRegister(name: string): void;
+      isRegistered?: (name: string) => boolean;
+      logVersions?: () => void;
+  }
+  const LIBRARIES: Libraries;
+  export default LIBRARIES;
+}

package/types/stable/@ember/-internals/metal/lib/namespace_search.d.ts

@@ -0,0 +1,19 @@
+declare module '@ember/-internals/metal/lib/namespace_search.d.ts' {
+  export interface Namespace {
+      isNamespace: true;
+      destroy(): void;
+  }
+  export const NAMESPACES: Namespace[];
+  export const NAMESPACES_BY_ID: {
+      [name: string]: Namespace;
+  };
+  export function addNamespace(namespace: Namespace): void;
+  export function removeNamespace(namespace: Namespace): void;
+  export function findNamespaces(): void;
+  export function findNamespace(name: string): Namespace | undefined;
+  export function processNamespace(namespace: Namespace): void;
+  export function processAllNamespaces(): void;
+  export function isSearchDisabled(): boolean;
+  export function setSearchDisabled(flag: boolean): void;
+  export function setUnprocessedMixins(): void;
+}

package/types/stable/@ember/-internals/metal/lib/observer.d.ts

@@ -0,0 +1,54 @@
+declare module '@ember/-internals/metal/lib/observer.d.ts' {
+  import type { Tag } from '@glimmer/validator';
+  interface ActiveObserver {
+      tag: Tag;
+      path: string;
+      lastRevision: number;
+      count: number;
+      suspended: boolean;
+  }
+  export const SYNC_OBSERVERS: Map<object, Map<string, ActiveObserver>>;
+  export const ASYNC_OBSERVERS: Map<object, Map<string, ActiveObserver>>;
+  /**
+  @module @ember/object
+  */
+  /**
+    @method addObserver
+    @static
+    @for @ember/object/observers
+    @param obj
+    @param {String} path
+    @param {Object|Function} target
+    @param {Function|String} [method]
+    @public
+  */
+  export function addObserver(obj: any, path: string, target: object | Function | null, method?: string | Function, sync?: boolean): void;
+  /**
+    @method removeObserver
+    @static
+    @for @ember/object/observers
+    @param obj
+    @param {String} path
+    @param {Object|Function} target
+    @param {Function|String} [method]
+    @public
+  */
+  export function removeObserver(obj: any, path: string, target: object | Function | null, method?: string | Function, sync?: boolean): void;
+  export function activateObserver(target: object, eventName: string, sync?: boolean): void;
+  export function deactivateObserver(target: object, eventName: string, sync?: boolean): void;
+  export function suspendedObserverDeactivation(): void;
+  export function resumeObserverDeactivation(): void;
+  /**
+   * Primarily used for cases where we are redefining a class, e.g. mixins/reopen
+   * being applied later. Revalidates all the observers, resetting their tags.
+   *
+   * @private
+   * @param target
+   */
+  export function revalidateObservers(target: object): void;
+  export function flushAsyncObservers(shouldSchedule?: boolean): void;
+  export function flushSyncObservers(): void;
+  export function setObserverSuspended(target: object, property: string, suspended: boolean): void;
+  export function destroyObservers(target: object): void;
+  export {};
+}

package/types/stable/@ember/-internals/metal/lib/path_cache.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/-internals/metal/lib/path_cache.d.ts' {
+  export function isPath(path: unknown): boolean;
+}

package/types/stable/@ember/-internals/metal/lib/properties.d.ts

@@ -0,0 +1,58 @@
+declare module '@ember/-internals/metal/lib/properties.d.ts' {
+  /**
+  @module @ember/object
+  */
+  import type { Meta } from '@ember/-internals/meta';
+  import type { ExtendedMethodDecorator } from './decorator';
+  /**
+    NOTE: This is a low-level method used by other parts of the API. You almost
+    never want to call this method directly. Instead you should use
+    `mixin()` to define new properties.
+
+    Defines a property on an object. This method works much like the ES5
+    `Object.defineProperty()` method except that it can also accept computed
+    properties and other special descriptors.
+
+    Normally this method takes only three parameters. However if you pass an
+    instance of `Descriptor` as the third param then you can pass an
+    optional value as the fourth parameter. This is often more efficient than
+    creating new descriptor hashes for each property.
+
+    ## Examples
+
+    ```javascript
+    import { defineProperty, computed } from '@ember/object';
+
+    // ES5 compatible mode
+    defineProperty(contact, 'firstName', {
+      writable: true,
+      configurable: false,
+      enumerable: true,
+      value: 'Charles'
+    });
+
+    // define a simple property
+    defineProperty(contact, 'lastName', undefined, 'Jolley');
+
+    // define a computed property
+    defineProperty(contact, 'fullName', computed('firstName', 'lastName', function() {
+      return this.firstName+' '+this.lastName;
+    }));
+    ```
+
+    @public
+    @method defineProperty
+    @static
+    @for @ember/object
+    @param {Object} obj the object to define this property on. This may be a prototype.
+    @param {String} keyName the name of the property
+    @param {Descriptor} [desc] an instance of `Descriptor` (typically a
+      computed property) or an ES5 descriptor.
+      You must provide this or `data` but not both.
+    @param {*} [data] something other than a descriptor, that will
+      become the explicit value of this property.
+  */
+  export function defineProperty(obj: object, keyName: string, desc?: ExtendedMethodDecorator | PropertyDescriptor | undefined | null, data?: any | undefined | null, _meta?: Meta): void;
+  export function defineDecorator(obj: object, keyName: string, desc: ExtendedMethodDecorator, meta: Meta): ExtendedMethodDecorator;
+  export function defineValue(obj: object, keyName: string, value: unknown, wasDescriptor: boolean, enumerable?: boolean): unknown;
+}

package/types/stable/@ember/-internals/metal/lib/property_events.d.ts

@@ -0,0 +1,59 @@
+declare module '@ember/-internals/metal/lib/property_events.d.ts' {
+  import type { Meta } from '@ember/-internals/meta';
+  /**
+   @module ember
+   @private
+   */
+  export const PROPERTY_DID_CHANGE: unique symbol;
+  export interface PropertyDidChange {
+      [PROPERTY_DID_CHANGE]: (keyName: string, value?: unknown) => void;
+  }
+  export function hasPropertyDidChange(obj: unknown): obj is PropertyDidChange;
+  /**
+    This function is called just after an object property has changed.
+    It will notify any observers and clear caches among other things.
+
+    Normally you will not need to call this method directly but if for some
+    reason you can't directly watch a property you can invoke this method
+    manually.
+
+    @method notifyPropertyChange
+    @for @ember/object
+    @param {Object} obj The object with the property that will change
+    @param {String} keyName The property key (or path) that will change.
+    @param {Meta} [_meta] The objects meta.
+    @param {unknown} [value] The new value to set for the property
+    @return {void}
+    @since 3.1.0
+    @public
+  */
+  function notifyPropertyChange(obj: object, keyName: string, _meta?: Meta | null, value?: unknown): void;
+  /**
+    @method beginPropertyChanges
+    @chainable
+    @private
+  */
+  function beginPropertyChanges(): void;
+  /**
+    @method endPropertyChanges
+    @private
+  */
+  function endPropertyChanges(): void;
+  /**
+    Make a series of property changes together in an
+    exception-safe way.
+
+    ```javascript
+    Ember.changeProperties(function() {
+      obj1.set('foo', mayBlowUpWhenSet);
+      obj2.set('bar', baz);
+    });
+    ```
+
+    @method changeProperties
+    @param {Function} callback
+    @private
+  */
+  function changeProperties(callback: () => void): void;
+  export { notifyPropertyChange, beginPropertyChanges, endPropertyChanges, changeProperties };
+}

package/types/stable/@ember/-internals/metal/lib/property_get.d.ts

@@ -0,0 +1,44 @@
+declare module '@ember/-internals/metal/lib/property_get.d.ts' {
+  export const PROXY_CONTENT: symbol;
+  export let getPossibleMandatoryProxyValue: (obj: object, keyName: string) => any;
+  export interface HasUnknownProperty {
+      unknownProperty: (keyName: string) => any;
+  }
+  export function hasUnknownProperty(val: unknown): val is HasUnknownProperty;
+  /**
+    Gets the value of a property on an object. If the property is computed,
+    the function will be invoked. If the property is not defined but the
+    object implements the `unknownProperty` method then that will be invoked.
+
+    ```javascript
+    import { get } from '@ember/object';
+    get(obj, "name");
+    ```
+
+    If you plan to run on IE8 and older browsers then you should use this
+    method anytime you want to retrieve a property on an object that you don't
+    know for sure is private. (Properties beginning with an underscore '_'
+    are considered private.)
+
+    On all newer browsers, you only need to use this method to retrieve
+    properties if the property might not be defined on the object and you want
+    to respect the `unknownProperty` handler. Otherwise you can ignore this
+    method.
+
+    Note that if the object itself is `undefined`, this method will throw
+    an error.
+
+    @method get
+    @for @ember/object
+    @static
+    @param {Object} obj The object to retrieve from.
+    @param {String} keyName The property key to retrieve
+    @return {Object} the property value or `null`.
+    @public
+  */
+  export function get<T extends object, K extends keyof T>(obj: T, keyName: K): T[K];
+  export function get(obj: unknown, keyName: string): unknown;
+  export function _getProp(obj: unknown, keyName: string): unknown;
+  export function _getPath(obj: unknown, path: string | string[], forSet?: boolean): any;
+  export default get;
+}

package/types/stable/@ember/-internals/metal/lib/property_set.d.ts

@@ -0,0 +1,52 @@
+declare module '@ember/-internals/metal/lib/property_set.d.ts' {
+  /**
+   @module @ember/object
+  */
+  /**
+    Sets the value of a property on an object, respecting computed properties
+    and notifying observers and other listeners of the change.
+    If the specified property is not defined on the object and the object
+    implements the `setUnknownProperty` method, then instead of setting the
+    value of the property on the object, its `setUnknownProperty` handler
+    will be invoked with the two parameters `keyName` and `value`.
+
+    ```javascript
+    import { set } from '@ember/object';
+    set(obj, "name", value);
+    ```
+
+    @method set
+    @static
+    @for @ember/object
+    @param {Object} obj The object to modify.
+    @param {String} keyName The property key to set
+    @param {Object} value The value to set
+    @return {Object} the passed value.
+    @public
+  */
+  export function set<T>(obj: object, keyName: string, value: T, tolerant?: boolean): T;
+  export function _setProp(obj: object, keyName: string, value: any): any;
+  /**
+    Error-tolerant form of `set`. Will not blow up if any part of the
+    chain is `undefined`, `null`, or destroyed.
+
+    This is primarily used when syncing bindings, which may try to update after
+    an object has been destroyed.
+
+    ```javascript
+    import { trySet } from '@ember/object';
+
+    let obj = { name: "Zoey" };
+    trySet(obj, "contacts.twitter", "@emberjs");
+    ```
+
+    @method trySet
+    @static
+    @for @ember/object
+    @param {Object} root The object to modify.
+    @param {String} path The property path to set
+    @param {Object} value The value to set
+    @public
+  */
+  export function trySet<T>(root: object, path: string, value: T): T | undefined;
+}

package/types/stable/@ember/-internals/metal/lib/set_properties.d.ts

@@ -0,0 +1,32 @@
+declare module '@ember/-internals/metal/lib/set_properties.d.ts' {
+  /**
+   @module @ember/object
+  */
+  /**
+    Set a list of properties on an object. These properties are set inside
+    a single `beginPropertyChanges` and `endPropertyChanges` batch, so
+    observers will be buffered.
+
+    ```javascript
+    import EmberObject from '@ember/object';
+    let anObject = EmberObject.create();
+
+    anObject.setProperties({
+      firstName: 'Stanley',
+      lastName: 'Stuart',
+      age: 21
+    });
+    ```
+
+    @method setProperties
+    @static
+    @for @ember/object
+    @param obj
+    @param {Object} properties
+    @return properties
+    @public
+  */
+  export default function setProperties<TProperties extends {
+      [key: string]: any;
+  }>(obj: object, properties: TProperties): TProperties;
+}

package/types/stable/@ember/-internals/metal/lib/tags.d.ts

@@ -0,0 +1,7 @@
+declare module '@ember/-internals/metal/lib/tags.d.ts' {
+  import type { Tag, TagMeta } from '@glimmer/validator';
+  export const SELF_TAG: string | symbol;
+  export function tagForProperty(obj: object, propertyKey: string | symbol, addMandatorySetter?: boolean, meta?: TagMeta): Tag;
+  export function tagForObject(obj: unknown | null): Tag;
+  export function markObjectAsDirty(obj: object, propertyKey: string): void;
+}

package/types/stable/@ember/-internals/metal/lib/tracked.d.ts

@@ -0,0 +1,78 @@
+declare module '@ember/-internals/metal/lib/tracked.d.ts' {
+  import type { ExtendedMethodDecorator, DecoratorPropertyDescriptor } from './decorator';
+  /**
+    @decorator
+    @private
+
+    Marks a property as tracked.
+
+    By default, a component's properties are expected to be static,
+    meaning you are not able to update them and have the template update accordingly.
+    Marking a property as tracked means that when that property changes,
+    a rerender of the component is scheduled so the template is kept up to date.
+
+    There are two usages for the `@tracked` decorator, shown below.
+
+    @example No dependencies
+
+    If you don't pass an argument to `@tracked`, only changes to that property
+    will be tracked:
+
+    ```typescript
+    import Component from '@glimmer/component';
+    import { tracked } from '@glimmer/tracking';
+
+    export default class MyComponent extends Component {
+      @tracked
+      remainingApples = 10
+    }
+    ```
+
+    When something changes the component's `remainingApples` property, the rerender
+    will be scheduled.
+
+    @example Dependents
+
+    In the case that you have a computed property that depends other
+    properties, you want to track both so that when one of the
+    dependents change, a rerender is scheduled.
+
+    In the following example we have two properties,
+    `eatenApples`, and `remainingApples`.
+
+    ```typescript
+    import Component from '@glimmer/component';
+    import { tracked } from '@glimmer/tracking';
+
+    const totalApples = 100;
+
+    export default class MyComponent extends Component {
+      @tracked
+      eatenApples = 0
+
+      get remainingApples() {
+        return totalApples - this.eatenApples;
+      }
+
+      increment() {
+        this.eatenApples = this.eatenApples + 1;
+      }
+    }
+    ```
+
+    @param dependencies Optional dependents to be tracked.
+  */
+  export function tracked(propertyDesc: {
+      value: any;
+      initializer: () => any;
+  }): ExtendedMethodDecorator;
+  export function tracked(target: object, key: string): void;
+  export function tracked(target: object, key: string, desc: DecoratorPropertyDescriptor): DecoratorPropertyDescriptor;
+  export class TrackedDescriptor {
+      private _get;
+      private _set;
+      constructor(_get: () => unknown, _set: (value: unknown) => void);
+      get(obj: object): unknown;
+      set(obj: object, _key: string, value: unknown): void;
+  }
+}

package/types/stable/@ember/-internals/overrides/index.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/-internals/overrides' {
+  export let onEmberGlobalAccess: any;
+}