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

package/types/stable/@ember/-internals/runtime/lib/mixins/action_handler.d.ts

@@ -0,0 +1,23 @@
+declare module '@ember/-internals/runtime/lib/mixins/action_handler.d.ts' {
+  /**
+  @module ember
+  */
+  import Mixin from '@ember/object/mixin';
+  /**
+    `Ember.ActionHandler` is available on some familiar classes including
+    `Route`, `Component`, and `Controller`.
+    (Internally the mixin is used by `Ember.CoreView`, `Ember.ControllerMixin`,
+    and `Route` and available to the above classes through
+    inheritance.)
+
+    @class ActionHandler
+    @namespace Ember
+    @private
+  */
+  interface ActionHandler {
+      actions?: Record<string, (...args: any[]) => unknown>;
+      send(actionName: string, ...args: unknown[]): void;
+  }
+  const ActionHandler: Mixin;
+  export default ActionHandler;
+}

package/types/stable/@ember/-internals/runtime/lib/mixins/comparable.d.ts

@@ -0,0 +1,22 @@
+declare module '@ember/-internals/runtime/lib/mixins/comparable.d.ts' {
+  import Mixin from '@ember/object/mixin';
+  /**
+  @module ember
+  */
+  /**
+    Implements some standard methods for comparing objects. Add this mixin to
+    any class you create that can compare its instances.
+
+    You should implement the `compare()` method.
+
+    @class Comparable
+    @namespace Ember
+    @since Ember 0.9
+    @private
+  */
+  interface Comparable {
+      compare: ((a: unknown, b: unknown) => -1 | 0 | 1) | null;
+  }
+  const Comparable: Mixin;
+  export default Comparable;
+}

package/types/stable/@ember/-internals/runtime/lib/mixins/container_proxy.d.ts

@@ -0,0 +1,22 @@
+declare module '@ember/-internals/runtime/lib/mixins/container_proxy.d.ts' {
+  /**
+  @module ember
+  */
+  import type Container from '@ember/-internals/container/lib/container';
+  import Mixin from '@ember/object/mixin';
+  import type { ContainerProxy } from '@ember/-internals/owner';
+  /**
+    ContainerProxyMixin is used to provide public access to specific
+    container functionality.
+
+    @class ContainerProxyMixin
+    @extends ContainerProxy
+    @private
+  */
+  interface ContainerProxyMixin extends ContainerProxy {
+      /** @internal */
+      __container__: Container;
+  }
+  const ContainerProxyMixin: Mixin;
+  export default ContainerProxyMixin;
+}

package/types/stable/@ember/-internals/runtime/lib/mixins/registry_proxy.d.ts

@@ -0,0 +1,22 @@
+declare module '@ember/-internals/runtime/lib/mixins/registry_proxy.d.ts' {
+  /**
+  @module ember
+  */
+  import type { Registry } from '@ember/-internals/container';
+  import type { RegistryProxy } from '@ember/-internals/owner';
+  import Mixin from '@ember/object/mixin';
+  /**
+    RegistryProxyMixin is used to provide public access to specific
+    registry functionality.
+
+    @class RegistryProxyMixin
+    @extends RegistryProxy
+    @private
+  */
+  interface RegistryProxyMixin extends RegistryProxy {
+      /** @internal */
+      __registry__: Registry;
+  }
+  const RegistryProxyMixin: Mixin;
+  export default RegistryProxyMixin;
+}

package/types/stable/@ember/-internals/runtime/lib/mixins/target_action_support.d.ts

@@ -0,0 +1,29 @@
+declare module '@ember/-internals/runtime/lib/mixins/target_action_support.d.ts' {
+  /**
+  @module ember
+  */
+  import Mixin from '@ember/object/mixin';
+  /**
+  `Ember.TargetActionSupport` is a mixin that can be included in a class
+  to add a `triggerAction` method with semantics similar to the Handlebars
+  `{{action}}` helper. In normal Ember usage, the `{{action}}` helper is
+  usually the best choice. This mixin is most often useful when you are
+  doing more complex event handling in Components.
+
+  @class TargetActionSupport
+  @namespace Ember
+  @extends Mixin
+  @private
+  */
+  interface TargetActionSupport {
+      target: unknown;
+      action: string | null;
+      actionContext: unknown;
+      actionContextObject: unknown;
+      triggerAction(opts?: object): unknown;
+      /** @internal */
+      _target?: unknown;
+  }
+  const TargetActionSupport: Mixin;
+  export default TargetActionSupport;
+}

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

@@ -0,0 +1,10 @@
+declare module '@ember/-internals/utility-types' {
+  export type AnyFn = (...args: any[]) => any;
+  export type MethodsOf<T> = {
+      [K in keyof T as T[K] extends AnyFn ? K : never]: T[K] extends AnyFn ? T[K] : never;
+  };
+  export type MethodNamesOf<T> = keyof MethodsOf<T>;
+  export type MethodParams<T, M extends MethodNamesOf<T>> = Parameters<MethodsOf<T>[M]>;
+  export type MethodReturns<T, M extends MethodNamesOf<T>> = ReturnType<MethodsOf<T>[M]>;
+  export type OmitFirst<F> = F extends [any, ...infer R] ? R : [];
+}

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

@@ -0,0 +1,16 @@
+declare module '@ember/-internals/utils' {
+  export { symbol, enumerableSymbol, isInternalSymbol } from './lib/symbol';
+  export { default as dictionary } from './lib/dictionary';
+  export { default as getDebugName } from './lib/get-debug-name';
+  export { uuid, GUID_KEY, generateGuid, guidFor } from './lib/guid';
+  export { default as intern } from './lib/intern';
+  export { checkHasSuper, ROOT, wrap, observerListenerMetaFor, setObservers, setListeners, } from './lib/super';
+  export { default as lookupDescriptor } from './lib/lookup-descriptor';
+  export { canInvoke } from './lib/invoke';
+  export { getName, setName } from './lib/name';
+  export { default as toString } from './lib/to-string';
+  export { isObject } from './lib/spec';
+  export { isProxy, setProxy } from './lib/is_proxy';
+  export { default as Cache } from './lib/cache';
+  export { setupMandatorySetter, teardownMandatorySetter, setWithMandatorySetter, } from './lib/mandatory-setter';
+}

package/types/stable/@ember/-internals/utils/lib/cache.d.ts

@@ -0,0 +1,14 @@
+declare module '@ember/-internals/utils/lib/cache.d.ts' {
+  export default class Cache<T, V> {
+      private limit;
+      private func;
+      private store;
+      size: number;
+      misses: number;
+      hits: number;
+      constructor(limit: number, func: (obj: T) => V, store?: Map<T, V>);
+      get(key: T): V;
+      set(key: T, value: V): V;
+      purge(): void;
+  }
+}

package/types/stable/@ember/-internals/utils/lib/dictionary.d.ts

@@ -0,0 +1,7 @@
+declare module '@ember/-internals/utils/lib/dictionary.d.ts' {
+  export default function makeDictionary<T>(parent: {
+      [key: string]: T;
+  } | null): {
+      [key: string]: T;
+  };
+}

package/types/stable/@ember/-internals/utils/lib/get-debug-name.d.ts

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/utils/lib/get-debug-name.d.ts' {
+  let getDebugName: undefined | ((value: any) => string);
+  export default getDebugName;
+}

package/types/stable/@ember/-internals/utils/lib/guid.d.ts

@@ -0,0 +1,60 @@
+declare module '@ember/-internals/utils/lib/guid.d.ts' {
+  /**
+   Generates a universally unique identifier. This method
+   is used internally by Ember for assisting with
+   the generation of GUID's and other unique identifiers.
+
+   @public
+   @return {Number} [description]
+   */
+  export function uuid(): number;
+  /**
+    A unique key used to assign guids and other private metadata to objects.
+    If you inspect an object in your browser debugger you will often see these.
+    They can be safely ignored.
+
+    On browsers that support it, these properties are added with enumeration
+    disabled so they won't show up when you iterate over your properties.
+
+    @private
+    @property GUID_KEY
+    @for Ember
+    @type String
+    @final
+  */
+  export const GUID_KEY: `__ember${number}`;
+  /**
+    Generates a new guid, optionally saving the guid to the object that you
+    pass in. You will rarely need to use this method. Instead you should
+    call `guidFor(obj)`, which return an existing guid if available.
+
+    @private
+    @method generateGuid
+    @static
+    @for @ember/object/internals
+    @param {Object} [obj] Object the guid will be used for. If passed in, the guid will
+      be saved on the object and reused whenever you pass the same object
+      again.
+
+      If no object is passed, just generate a new guid.
+    @param {String} [prefix] Prefix to place in front of the guid. Useful when you want to
+      separate the guid into separate namespaces.
+    @return {String} the guid
+  */
+  export function generateGuid(obj: object, prefix?: string): String;
+  /**
+    Returns a unique id for the object. If the object does not yet have a guid,
+    one will be assigned to it. You can call this on any object,
+    `EmberObject`-based or not.
+
+    You can also use this method on DOM Element objects.
+
+    @public
+    @static
+    @method guidFor
+    @for @ember/object/internals
+    @param {Object} obj any object, string, number, Element, or primitive
+    @return {String} the unique guid for this instance.
+  */
+  export function guidFor(value: any | null | undefined): string;
+}

package/types/stable/@ember/-internals/utils/lib/intern.d.ts

@@ -0,0 +1,42 @@
+declare module '@ember/-internals/utils/lib/intern.d.ts' {
+  /**
+    Strongly hint runtimes to intern the provided string.
+
+    When do I need to use this function?
+
+    For the most part, never. Pre-mature optimization is bad, and often the
+    runtime does exactly what you need it to, and more often the trade-off isn't
+    worth it.
+
+    Why?
+
+    Runtimes store strings in at least 2 different representations:
+    Ropes and Symbols (interned strings). The Rope provides a memory efficient
+    data-structure for strings created from concatenation or some other string
+    manipulation like splitting.
+
+    Unfortunately checking equality of different ropes can be quite costly as
+    runtimes must resort to clever string comparison algorithms. These
+    algorithms typically cost in proportion to the length of the string.
+    Luckily, this is where the Symbols (interned strings) shine. As Symbols are
+    unique by their string content, equality checks can be done by pointer
+    comparison.
+
+    How do I know if my string is a rope or symbol?
+
+    Typically (warning general sweeping statement, but truthy in runtimes at
+    present) static strings created as part of the JS source are interned.
+    Strings often used for comparisons can be interned at runtime if some
+    criteria are met.  One of these criteria can be the size of the entire rope.
+    For example, in chrome 38 a rope longer then 12 characters will not
+    intern, nor will segments of that rope.
+
+    Some numbers: http://jsperf.com/eval-vs-keys/8
+
+    Known Trick™
+
+    @private
+    @return {String} interned version of the provided string
+  */
+  export default function intern<S extends string>(str: S): S;
+}

package/types/stable/@ember/-internals/utils/lib/invoke.d.ts

@@ -0,0 +1,24 @@
+declare module '@ember/-internals/utils/lib/invoke.d.ts' {
+  /**
+    Checks to see if the `methodName` exists on the `obj`.
+
+    ```javascript
+    let foo = { bar: function() { return 'bar'; }, baz: null };
+
+    Ember.canInvoke(foo, 'bar'); // true
+    Ember.canInvoke(foo, 'baz'); // false
+    Ember.canInvoke(foo, 'bat'); // false
+    ```
+
+    @method canInvoke
+    @for Ember
+    @param {Object} obj The object to check for the method
+    @param {String} methodName The method name to check for
+    @return {Boolean}
+    @private
+  */
+  export function canInvoke(obj: unknown, methodName: string): boolean;
+  /**
+    @module @ember/utils
+  */
+}

package/types/stable/@ember/-internals/utils/lib/is_proxy.d.ts

@@ -0,0 +1,5 @@
+declare module '@ember/-internals/utils/lib/is_proxy.d.ts' {
+  import type ProxyMixin from '@ember/-internals/runtime/lib/mixins/-proxy';
+  export function isProxy(value: unknown): value is ProxyMixin<unknown>;
+  export function setProxy(object: ProxyMixin<unknown>): void;
+}

package/types/stable/@ember/-internals/utils/lib/lookup-descriptor.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/-internals/utils/lib/lookup-descriptor.d.ts' {
+  export default function lookupDescriptor(obj: object, keyName: string | symbol): PropertyDescriptor | null;
+}

package/types/stable/@ember/-internals/utils/lib/mandatory-setter.d.ts

@@ -0,0 +1,6 @@
+declare module '@ember/-internals/utils/lib/mandatory-setter.d.ts' {
+  import type { Tag } from '@glimmer/validator';
+  export let setupMandatorySetter: ((tag: Tag, obj: object, keyName: string | symbol) => void) | undefined;
+  export let teardownMandatorySetter: ((obj: object, keyName: string | symbol) => void) | undefined;
+  export let setWithMandatorySetter: ((obj: object, keyName: string, value: any) => void) | undefined;
+}

package/types/stable/@ember/-internals/utils/lib/name.d.ts

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/utils/lib/name.d.ts' {
+  export function setName(obj: object, name: string): void;
+  export function getName(obj: object): string | undefined;
+}

package/types/stable/@ember/-internals/utils/lib/spec.d.ts

@@ -0,0 +1,14 @@
+declare module '@ember/-internals/utils/lib/spec.d.ts' {
+  /**
+    Returns whether Type(value) is Object.
+
+    Useful for checking whether a value is a valid WeakMap key.
+
+    Refs: https://tc39.github.io/ecma262/#sec-typeof-operator-runtime-semantics-evaluation
+          https://tc39.github.io/ecma262/#sec-weakmap.prototype.set
+
+    @private
+    @function isObject
+  */
+  export function isObject(value: any | null | undefined): value is object;
+}

package/types/stable/@ember/-internals/utils/lib/super.d.ts

@@ -0,0 +1,31 @@
+declare module '@ember/-internals/utils/lib/super.d.ts' {
+  export const checkHasSuper: (func: Function) => boolean;
+  export const ROOT: () => void;
+  class ObserverListenerMeta {
+      listeners?: string[];
+      observers?: {
+          paths: string[];
+          sync: boolean;
+      };
+  }
+  export function observerListenerMetaFor(fn: Function): ObserverListenerMeta | undefined;
+  export function setObservers(func: Function, observers: {
+      paths: string[];
+      sync: boolean;
+  }): void;
+  export function setListeners(func: Function, listeners: string[]): void;
+  /**
+    Wraps the passed function so that `this._super` will point to the superFunc
+    when the function is invoked. This is the primitive we use to implement
+    calls to super.
+
+    @private
+    @method wrap
+    @for Ember
+    @param {Function} func The function to call
+    @param {Function} superFunc The super function.
+    @return {Function} wrapped function.
+  */
+  export function wrap(func: Function, superFunc: Function): Function;
+  export {};
+}

package/types/stable/@ember/-internals/utils/lib/symbol.d.ts

@@ -0,0 +1,5 @@
+declare module '@ember/-internals/utils/lib/symbol.d.ts' {
+  export function isInternalSymbol(possibleSymbol: string): boolean;
+  export function enumerableSymbol(debugName: string): string;
+  export const symbol: SymbolConstructor;
+}

package/types/stable/@ember/-internals/utils/lib/to-string.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/-internals/utils/lib/to-string.d.ts' {
+  export default function toString(obj: any | undefined | null): string;
+}

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

@@ -0,0 +1,13 @@
+declare module '@ember/-internals/views' {
+  export { addChildView, isSimpleClick, getViewBounds, getViewClientRects, getViewBoundingClientRect, getRootViews, getChildViews, getViewId, getElementView, getViewElement, setElementView, setViewElement, clearElementView, clearViewElement, constructStyleDeprecationMessage, } from './lib/system/utils';
+  export { default as EventDispatcher } from './lib/system/event_dispatcher';
+  export { default as ComponentLookup } from './lib/component_lookup';
+  export { default as CoreView } from './lib/views/core_view';
+  export { default as ClassNamesSupport } from './lib/mixins/class_names_support';
+  export { default as ChildViewsSupport } from './lib/mixins/child_views_support';
+  export { default as ViewStateSupport } from './lib/mixins/view_state_support';
+  export { default as ViewMixin } from './lib/mixins/view_support';
+  export { default as ActionSupport } from './lib/mixins/action_support';
+  export { MUTABLE_CELL } from './lib/compat/attrs';
+  export { default as ActionManager } from './lib/system/action_manager';
+}

package/types/stable/@ember/-internals/views/lib/compat/attrs.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/-internals/views/lib/compat/attrs.d.ts' {
+  export const MUTABLE_CELL: unique symbol;
+}

package/types/stable/@ember/-internals/views/lib/compat/fallback-view-registry.d.ts

@@ -0,0 +1,6 @@
+declare module '@ember/-internals/views/lib/compat/fallback-view-registry.d.ts' {
+  const _default: {
+      [key: string]: unknown;
+  };
+  export default _default;
+}

package/types/stable/@ember/-internals/views/lib/component_lookup.d.ts

@@ -0,0 +1,5 @@
+declare module '@ember/-internals/views/lib/component_lookup.d.ts' {
+  import EmberObject from '@ember/object';
+  const _default: Readonly<typeof EmberObject> & (new (owner?: import("@ember/-internals/owner").default | undefined) => EmberObject);
+  export default _default;
+}

package/types/stable/@ember/-internals/views/lib/mixins/action_support.d.ts

@@ -0,0 +1,13 @@
+declare module '@ember/-internals/views/lib/mixins/action_support.d.ts' {
+  import Mixin from '@ember/object/mixin';
+  /**
+   @class ActionSupport
+   @namespace Ember
+   @private
+  */
+  interface ActionSupport {
+      send(actionName: string, ...args: unknown[]): void;
+  }
+  const ActionSupport: Mixin;
+  export default ActionSupport;
+}

package/types/stable/@ember/-internals/views/lib/mixins/child_views_support.d.ts

@@ -0,0 +1,13 @@
+declare module '@ember/-internals/views/lib/mixins/child_views_support.d.ts' {
+  /**
+  @module ember
+  */
+  import type { View } from '@ember/-internals/glimmer/lib/renderer';
+  import Mixin from '@ember/object/mixin';
+  interface ChildViewsSupport {
+      readonly childViews: View[];
+      appendChild(view: View): void;
+  }
+  const ChildViewsSupport: Mixin;
+  export default ChildViewsSupport;
+}

package/types/stable/@ember/-internals/views/lib/mixins/class_names_support.d.ts

@@ -0,0 +1,14 @@
+declare module '@ember/-internals/views/lib/mixins/class_names_support.d.ts' {
+  import Mixin from '@ember/object/mixin';
+  /**
+    @class ClassNamesSupport
+    @namespace Ember
+    @private
+  */
+  interface ClassNamesSupport {
+      classNames: string[];
+      classNameBindings: string[];
+  }
+  const ClassNamesSupport: Mixin;
+  export default ClassNamesSupport;
+}

package/types/stable/@ember/-internals/views/lib/mixins/view_state_support.d.ts

@@ -0,0 +1,13 @@
+declare module '@ember/-internals/views/lib/mixins/view_state_support.d.ts' {
+  /**
+  @module ember
+  */
+  import Mixin from '@ember/object/mixin';
+  import type states from '../views/states';
+  interface ViewStateSupport {
+      /** @internal */
+      _transitionTo(state: keyof typeof states): void;
+  }
+  const ViewStateSupport: Mixin;
+  export default ViewStateSupport;
+}

package/types/stable/@ember/-internals/views/lib/mixins/view_support.d.ts

@@ -0,0 +1,25 @@
+declare module '@ember/-internals/views/lib/mixins/view_support.d.ts' {
+  import Mixin from '@ember/object/mixin';
+  import type { SimpleElement } from '@simple-dom/interface';
+  /**
+   @class ViewMixin
+   @namespace Ember
+   @private
+  */
+  interface ViewMixin {
+      rerender(): unknown;
+      element: SimpleElement;
+      appendTo(selector: string | Element | SimpleElement): this;
+      append(): this;
+      elementId: string | null;
+      willInsertElement(): void;
+      didInsertElement(): void;
+      willClearRender(): void;
+      willDestroyElement(): void;
+      parentViewDidChange(): void;
+      tagName: string | null;
+      handleEvent(eventName: string, evt: Event): boolean;
+  }
+  const ViewMixin: Mixin;
+  export default ViewMixin;
+}

package/types/stable/@ember/-internals/views/lib/system/action_manager.d.ts

@@ -0,0 +1,11 @@
+declare module '@ember/-internals/views/lib/system/action_manager.d.ts' {
+  import type { ActionState } from '@ember/-internals/glimmer/lib/modifiers/action';
+  /**
+  @module ember
+  */
+  function ActionManager(): void;
+  namespace ActionManager {
+      var registeredActions: Record<string, ActionState>;
+  }
+  export default ActionManager;
+}

package/types/stable/@ember/-internals/views/lib/system/event_dispatcher.d.ts

@@ -0,0 +1,117 @@
+declare module '@ember/-internals/views/lib/system/event_dispatcher.d.ts' {
+  import EmberObject from '@ember/object';
+  /**
+    `Ember.EventDispatcher` handles delegating browser events to their
+    corresponding `Ember.Views.` For example, when you click on a view,
+    `Ember.EventDispatcher` ensures that that view's `mouseDown` method gets
+    called.
+
+    @class EventDispatcher
+    @namespace Ember
+    @private
+    @extends EmberObject
+  */
+  export default class EventDispatcher extends EmberObject {
+      /**
+        The set of events names (and associated handler function names) to be setup
+        and dispatched by the `EventDispatcher`. Modifications to this list can be done
+        at setup time, generally via the `Application.customEvents` hash.
+    
+        To add new events to be listened to:
+    
+        ```javascript
+        import Application from '@ember/application';
+    
+        let App = Application.create({
+          customEvents: {
+            paste: 'paste'
+          }
+        });
+        ```
+    
+        To prevent default events from being listened to:
+    
+        ```javascript
+        import Application from '@ember/application';
+    
+        let App = Application.create({
+          customEvents: {
+            mouseenter: null,
+            mouseleave: null
+          }
+        });
+        ```
+        @property events
+        @type Object
+        @private
+      */
+      events: Record<string, string>;
+      /**
+        The root DOM element to which event listeners should be attached. Event
+        listeners will be attached to the document unless this is overridden.
+    
+        Can be specified as a DOMElement or a selector string.
+    
+        The default body is a string since this may be evaluated before document.body
+        exists in the DOM.
+    
+        @private
+        @property rootElement
+        @type DOMElement
+        @default 'body'
+      */
+      rootElement: string | Element;
+      _eventHandlers: any;
+      _didSetup: boolean;
+      finalEventNameMapping: Record<string, string> | null;
+      _sanitizedRootElement: Element | null;
+      lazyEvents: Map<string, string | null>;
+      _reverseEventNameMapping: Record<string, string> | null;
+      /**
+        Sets up event listeners for standard browser events.
+    
+        This will be called after the browser sends a `DOMContentReady` event. By
+        default, it will set up all of the listeners on the document body. If you
+        would like to register the listeners on a different element, set the event
+        dispatcher's `root` property.
+    
+        @private
+        @method setup
+        @param addedEvents {Object}
+      */
+      setup(addedEvents: Record<string, string | null>, _rootElement: string | Element | null): void;
+      /**
+        Setup event listeners for the given browser event name
+    
+        @private
+        @method setupHandlerForBrowserEvent
+        @param event the name of the event in the browser
+      */
+      setupHandlerForBrowserEvent(event: string): void;
+      /**
+        Setup event listeners for the given Ember event name (camel case)
+    
+        @private
+        @method setupHandlerForEmberEvent
+        @param eventName
+      */
+      setupHandlerForEmberEvent(eventName: string): void;
+      /**
+        Registers an event listener on the rootElement. If the given event is
+        triggered, the provided event handler will be triggered on the target view.
+    
+        If the target view does not implement the event handler, or if the handler
+        returns `false`, the parent view will be called. The event will continue to
+        bubble to each successive parent view until it reaches the top.
+    
+        @private
+        @method setupHandler
+        @param {Element} rootElement
+        @param {String} event the name of the event in the browser
+        @param {String} eventName the name of the method to call on the view
+      */
+      setupHandler(rootElement: Element, event: string, eventName: string | null): void;
+      destroy(): any;
+      toString(): string;
+  }
+}