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

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

@@ -0,0 +1,3 @@
+declare module '@ember/-internals/bootstrap' {
+  export {};
+}

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

@@ -0,0 +1,9 @@
+declare module '@ember/-internals/browser-environment' {
+  export { default as hasDOM } from './lib/has-dom';
+  export const window: (Window & typeof globalThis) | null;
+  export const location: Location | null;
+  export const history: History | null;
+  export const userAgent: string;
+  export const isChrome: boolean;
+  export const isFirefox: boolean;
+}

package/types/stable/@ember/-internals/browser-environment/lib/has-dom.d.ts

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/browser-environment/lib/has-dom.d.ts' {
+  const _default: boolean;
+  export default _default;
+}

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

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/container' {
+  export { default as Registry, ResolverClass, privatize } from './lib/registry';
+  export { default as Container, getFactoryFor, setFactoryFor, INIT_FACTORY } from './lib/container';
+}

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

@@ -0,0 +1,164 @@
+declare module '@ember/-internals/container/lib/container.d.ts' {
+  import type { InternalFactory, FactoryClass, InternalOwner, RegisterOptions, FactoryManager, FullName } from '@ember/-internals/owner';
+  import type { DebugRegistry } from './registry';
+  import type Registry from './registry';
+  interface LeakTracking {
+      hasContainers(): boolean;
+      reset(): void;
+  }
+  export interface ContainerOptions {
+      owner?: InternalOwner;
+      cache?: {
+          [key: string]: object;
+      };
+      factoryManagerCache?: {
+          [key: string]: InternalFactoryManager<any, any>;
+      };
+      validationCache?: {
+          [key: string]: boolean;
+      };
+  }
+  /**
+   A container used to instantiate and cache objects.
+
+   Every `Container` must be associated with a `Registry`, which is referenced
+   to determine the factory and options that should be used to instantiate
+   objects.
+
+   The public API for `Container` is still in flux and should not be considered
+   stable.
+
+   @private
+   @class Container
+   */
+  export default class Container {
+      static _leakTracking: LeakTracking;
+      readonly owner: InternalOwner | null;
+      readonly registry: Registry & DebugRegistry;
+      cache: {
+          [key: string]: object;
+      };
+      factoryManagerCache: {
+          [key: string]: InternalFactoryManager<object>;
+      };
+      readonly validationCache: {
+          [key: string]: boolean;
+      };
+      isDestroyed: boolean;
+      isDestroying: boolean;
+      constructor(registry: Registry, options?: ContainerOptions);
+      /**
+       @private
+       @property registry
+       @type Registry
+       @since 1.11.0
+       */
+      /**
+       @private
+       @property cache
+       @type InheritingDict
+       */
+      /**
+       @private
+       @property validationCache
+       @type InheritingDict
+       */
+      /**
+       Given a fullName return a corresponding instance.
+        The default behavior is for lookup to return a singleton instance.
+       The singleton is scoped to the container, allowing multiple containers
+       to all have their own locally scoped singletons.
+        ```javascript
+       let registry = new Registry();
+       let container = registry.container();
+        registry.register('api:twitter', Twitter);
+        let twitter = container.lookup('api:twitter');
+        twitter instanceof Twitter; // => true
+        // by default the container will return singletons
+       let twitter2 = container.lookup('api:twitter');
+       twitter2 instanceof Twitter; // => true
+        twitter === twitter2; //=> true
+       ```
+        If singletons are not wanted, an optional flag can be provided at lookup.
+        ```javascript
+       let registry = new Registry();
+       let container = registry.container();
+        registry.register('api:twitter', Twitter);
+        let twitter = container.lookup('api:twitter', { singleton: false });
+       let twitter2 = container.lookup('api:twitter', { singleton: false });
+        twitter === twitter2; //=> false
+       ```
+        @private
+       @method lookup
+       @param {String} fullName
+       @param {RegisterOptions} [options]
+       @return {any}
+       */
+      lookup(fullName: string, options?: RegisterOptions): InternalFactory<object> | object | undefined;
+      /**
+       A depth first traversal, destroying the container, its descendant containers and all
+       their managed objects.
+        @private
+       @method destroy
+       */
+      destroy(): void;
+      finalizeDestroy(): void;
+      /**
+       Clear either the entire cache or just the cache for a particular key.
+    
+       @private
+       @method reset
+       @param {String} fullName optional key to reset; if missing, resets everything
+      */
+      reset(fullName: FullName): void;
+      /**
+       Returns an object that can be used to provide an owner to a
+       manually created instance.
+        @private
+       @method ownerInjection
+       @returns { Object }
+      */
+      ownerInjection(): {};
+      /**
+       Given a fullName, return the corresponding factory. The consumer of the factory
+       is responsible for the destruction of any factory instances, as there is no
+       way for the container to ensure instances are destroyed when it itself is
+       destroyed.
+        @public
+       @method factoryFor
+       @param {String} fullName
+       @return {any}
+       */
+      factoryFor(fullName: FullName): InternalFactoryManager<object> | undefined;
+  }
+  export interface LazyInjection {
+      namespace: string | undefined;
+      source: string | undefined;
+      specifier: string;
+  }
+  interface DebugFactory<T extends object, C extends FactoryClass | object = FactoryClass> extends InternalFactory<T, C> {
+      _onLookup?: (fullName: string) => void;
+      _lazyInjections?: () => {
+          [key: string]: LazyInjection;
+      };
+      _initFactory?: (factoryManager: InternalFactoryManager<T, C>) => void;
+  }
+  export const INIT_FACTORY: unique symbol;
+  export function getFactoryFor(obj: object): InternalFactoryManager<object, FactoryClass | object> | undefined;
+  export function setFactoryFor<T extends object, C extends FactoryClass | object>(obj: object, factory: InternalFactoryManager<T, C>): void;
+  export class InternalFactoryManager<T extends object, C extends FactoryClass | object = FactoryClass> implements FactoryManager<T> {
+      readonly container: Container;
+      readonly owner: InternalOwner | null;
+      readonly class: DebugFactory<T, C>;
+      readonly fullName: FullName;
+      readonly normalizedName: string;
+      private madeToString;
+      injections: {
+          [key: string]: unknown;
+      } | undefined;
+      constructor(container: Container, factory: InternalFactory<T, C>, fullName: FullName, normalizedName: string);
+      toString(): string;
+      create(options?: Partial<T>): T;
+  }
+  export {};
+}

package/types/stable/@ember/-internals/container/lib/registry.d.ts

@@ -0,0 +1,292 @@
+declare module '@ember/-internals/container/lib/registry.d.ts' {
+  import type { FactoryClass, FullName, InternalFactory, KnownForTypeResult, RegisterOptions, Resolver } from '@ember/-internals/owner';
+  import type { set } from '@ember/object';
+  import type { ContainerOptions, LazyInjection } from './container';
+  import Container from './container';
+  export interface Injection {
+      property: string;
+      specifier: FullName;
+  }
+  export interface ResolverClass {
+      create(...args: unknown[]): Resolver;
+  }
+  export interface RegistryOptions {
+      fallback?: Registry;
+      registrations?: {
+          [key: string]: object;
+      };
+      resolver?: Resolver;
+  }
+  /**
+   A registry used to store factory and option information keyed
+   by type.
+
+   A `Registry` stores the factory and option information needed by a
+   `Container` to instantiate and cache objects.
+
+   The API for `Registry` is still in flux and should not be considered stable.
+
+   @private
+   @class Registry
+   @since 1.11.0
+  */
+  export default class Registry {
+      readonly _failSet: Set<string>;
+      resolver: Resolver | null;
+      readonly fallback: Registry | null;
+      readonly registrations: Record<string, InternalFactory<object> | object>;
+      readonly _normalizeCache: Record<FullName, FullName>;
+      readonly _options: Record<string, RegisterOptions>;
+      readonly _resolveCache: Record<string, InternalFactory<object> | object>;
+      readonly _typeOptions: Record<string, RegisterOptions>;
+      set?: typeof set;
+      constructor(options?: RegistryOptions);
+      /**
+       A backup registry for resolving registrations when no matches can be found.
+    
+       @private
+       @property fallback
+       @type Registry
+       */
+      /**
+       An object that has a `resolve` method that resolves a name.
+    
+       @private
+       @property resolver
+       @type Resolver
+       */
+      /**
+       @private
+       @property registrations
+       @type InheritingDict
+       */
+      /**
+       @private
+    
+       @property _normalizeCache
+       @type InheritingDict
+       */
+      /**
+       @private
+    
+       @property _resolveCache
+       @type InheritingDict
+       */
+      /**
+       @private
+    
+       @property _options
+       @type InheritingDict
+       */
+      /**
+       @private
+    
+       @property _typeOptions
+       @type InheritingDict
+       */
+      /**
+       Creates a container based on this registry.
+    
+       @private
+       @method container
+       @param {Object} options
+       @return {Container} created container
+       */
+      container(options?: ContainerOptions): Container;
+      /**
+       Registers a factory for later injection.
+    
+       Example:
+    
+       ```javascript
+       let registry = new Registry();
+    
+       registry.register('model:user', Person, {singleton: false });
+       registry.register('fruit:favorite', Orange);
+       registry.register('communication:main', Email, {singleton: false});
+       ```
+    
+       @private
+       @method register
+       @param {String} fullName
+       @param {Function} factory
+       @param {Object} options
+       */
+      register(fullName: FullName, factory: object, options: RegisterOptions & {
+          instantiate: false;
+      }): void;
+      register<T extends object, C extends FactoryClass | object>(fullName: FullName, factory: InternalFactory<T, C>, options?: RegisterOptions): void;
+      /**
+       Unregister a fullName
+    
+       ```javascript
+       let registry = new Registry();
+       registry.register('model:user', User);
+    
+       registry.resolve('model:user').create() instanceof User //=> true
+    
+       registry.unregister('model:user')
+       registry.resolve('model:user') === undefined //=> true
+       ```
+    
+       @private
+       @method unregister
+       @param {String} fullName
+       */
+      unregister(fullName: FullName): void;
+      /**
+       Given a fullName return the corresponding factory.
+    
+       By default `resolve` will retrieve the factory from
+       the registry.
+    
+       ```javascript
+       let registry = new Registry();
+       registry.register('api:twitter', Twitter);
+    
+       registry.resolve('api:twitter') // => Twitter
+       ```
+    
+       Optionally the registry can be provided with a custom resolver.
+       If provided, `resolve` will first provide the custom resolver
+       the opportunity to resolve the fullName, otherwise it will fallback
+       to the registry.
+    
+       ```javascript
+       let registry = new Registry();
+       registry.resolver = function(fullName) {
+          // lookup via the module system of choice
+        };
+    
+       // the twitter factory is added to the module system
+       registry.resolve('api:twitter') // => Twitter
+       ```
+    
+       @private
+       @method resolve
+       @param {String} fullName
+       @return {Function} fullName's factory
+       */
+      resolve(fullName: FullName): InternalFactory<object> | object | undefined;
+      /**
+       A hook that can be used to describe how the resolver will
+       attempt to find the factory.
+    
+       For example, the default Ember `.describe` returns the full
+       class name (including namespace) where Ember's resolver expects
+       to find the `fullName`.
+    
+       @private
+       @method describe
+       @param {String} fullName
+       @return {string} described fullName
+       */
+      describe(fullName: FullName): string;
+      /**
+       A hook to enable custom fullName normalization behavior
+    
+       @private
+       @method normalizeFullName
+       @param {String} fullName
+       @return {string} normalized fullName
+       */
+      normalizeFullName(fullName: FullName): FullName;
+      /**
+       Normalize a fullName based on the application's conventions
+    
+       @private
+       @method normalize
+       @param {String} fullName
+       @return {string} normalized fullName
+       */
+      normalize(fullName: FullName): FullName;
+      /**
+       @method makeToString
+    
+       @private
+       @param {any} factory
+       @param {string} fullName
+       @return {function} toString function
+       */
+      makeToString(factory: InternalFactory<object>, fullName: FullName): string;
+      /**
+       Given a fullName check if the container is aware of its factory
+       or singleton instance.
+    
+       @private
+       @method has
+       @param {String} fullName
+       @param {Object} [options]
+       @param {String} [options.source] the fullname of the request source (used for local lookups)
+       @return {Boolean}
+       */
+      has(fullName: FullName): boolean;
+      /**
+       Allow registering options for all factories of a type.
+    
+       ```javascript
+       let registry = new Registry();
+       let container = registry.container();
+    
+       // if all of type `connection` must not be singletons
+       registry.optionsForType('connection', { singleton: false });
+    
+       registry.register('connection:twitter', TwitterConnection);
+       registry.register('connection:facebook', FacebookConnection);
+    
+       let twitter = container.lookup('connection:twitter');
+       let twitter2 = container.lookup('connection:twitter');
+    
+       twitter === twitter2; // => false
+    
+       let facebook = container.lookup('connection:facebook');
+       let facebook2 = container.lookup('connection:facebook');
+    
+       facebook === facebook2; // => false
+       ```
+    
+       @private
+       @method optionsForType
+       @param {String} type
+       @param {Object} options
+       */
+      optionsForType(type: string, options: RegisterOptions): void;
+      getOptionsForType(type: string): RegisterOptions | undefined;
+      /**
+       @private
+       @method options
+       @param {String} fullName
+       @param {Object} options
+       */
+      options(fullName: FullName, options: RegisterOptions): void;
+      getOptions(fullName: FullName): RegisterOptions | undefined;
+      getOption<K extends keyof RegisterOptions>(fullName: FullName, optionName: K): RegisterOptions[K] | undefined;
+      /**
+       This is deprecated in favor of explicit injection of dependencies.
+    
+       Reference: https://deprecations.emberjs.com/v3.x#toc_implicit-injections
+       ```
+    
+       @private
+       @method injection
+       @param {String} fullName
+       @param {String} property
+       @deprecated
+       */
+      injection(fullName: FullName, property: string): void;
+      /**
+       @private
+       @method knownForType
+       @param {String} type the type to iterate over
+      */
+      knownForType<T extends string>(type: T): KnownForTypeResult<T>;
+      isValidFullName(fullName: string): fullName is FullName;
+  }
+  export class DebugRegistry extends Registry {
+      normalizeInjectionsHash(hash: {
+          [key: string]: LazyInjection;
+      }): Injection[];
+      validateInjections(injections: Injection[]): void;
+  }
+  export function privatize([fullName]: TemplateStringsArray): FullName;
+}

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

@@ -0,0 +1,5 @@
+declare module '@ember/-internals/environment' {
+  export * from './lib/context';
+  export * from './lib/env';
+  export { default as global } from './lib/global';
+}

package/types/stable/@ember/-internals/environment/lib/context.d.ts

@@ -0,0 +1,10 @@
+declare module '@ember/-internals/environment/lib/context.d.ts' {
+  export interface GlobalContext {
+      imports: object;
+      exports: object;
+      lookup: Record<string, unknown>;
+  }
+  export const context: GlobalContext;
+  export function getLookup(): Record<string, unknown>;
+  export function setLookup(value: Record<string, unknown>): void;
+}

package/types/stable/@ember/-internals/environment/lib/env.d.ts

@@ -0,0 +1,153 @@
+declare module '@ember/-internals/environment/lib/env.d.ts' {
+  /**
+    The hash of environment variables used to control various configuration
+    settings. To specify your own or override default settings, add the
+    desired properties to a global hash named `EmberENV` (or `ENV` for
+    backwards compatibility with earlier versions of Ember). The `EmberENV`
+    hash must be created before loading Ember.
+
+    @class EmberENV
+    @type Object
+    @public
+  */
+  export const ENV: {
+      ENABLE_OPTIONAL_FEATURES: boolean;
+      /**
+        Determines whether Ember should add to `Array`
+        native object prototypes, a few extra methods in order to provide a more
+        friendly API.
+    
+        We generally recommend leaving this option set to true however, if you need
+        to turn it off, you can add the configuration property
+        `EXTEND_PROTOTYPES` to `EmberENV` and set it to `false`.
+    
+        Note, when disabled (the default configuration for Ember Addons), you will
+        instead have to access all methods and functions from the Ember
+        namespace.
+    
+        @property EXTEND_PROTOTYPES
+        @type Boolean
+        @default true
+        @for EmberENV
+        @public
+      */
+      EXTEND_PROTOTYPES: {
+          Array: boolean;
+      };
+      /**
+        The `LOG_STACKTRACE_ON_DEPRECATION` property, when true, tells Ember to log
+        a full stack trace during deprecation warnings.
+    
+        @property LOG_STACKTRACE_ON_DEPRECATION
+        @type Boolean
+        @default true
+        @for EmberENV
+        @public
+      */
+      LOG_STACKTRACE_ON_DEPRECATION: boolean;
+      /**
+        The `LOG_VERSION` property, when true, tells Ember to log versions of all
+        dependent libraries in use.
+    
+        @property LOG_VERSION
+        @type Boolean
+        @default true
+        @for EmberENV
+        @public
+      */
+      LOG_VERSION: boolean;
+      RAISE_ON_DEPRECATION: boolean;
+      STRUCTURED_PROFILE: boolean;
+      /**
+        Whether to insert a `<div class="ember-view" />` wrapper around the
+        application template. See RFC #280.
+    
+        This is not intended to be set directly, as the implementation may change in
+        the future. Use `@ember/optional-features` instead.
+    
+        @property _APPLICATION_TEMPLATE_WRAPPER
+        @for EmberENV
+        @type Boolean
+        @default true
+        @private
+      */
+      _APPLICATION_TEMPLATE_WRAPPER: boolean;
+      /**
+        Whether to use Glimmer Component semantics (as opposed to the classic "Curly"
+        components semantics) for template-only components. See RFC #278.
+    
+        This is not intended to be set directly, as the implementation may change in
+        the future. Use `@ember/optional-features` instead.
+    
+        @property _TEMPLATE_ONLY_GLIMMER_COMPONENTS
+        @for EmberENV
+        @type Boolean
+        @default false
+        @private
+      */
+      _TEMPLATE_ONLY_GLIMMER_COMPONENTS: boolean;
+      /**
+        Whether to perform extra bookkeeping needed to make the `captureRenderTree`
+        API work.
+    
+        This has to be set before the ember JavaScript code is evaluated. This is
+        usually done by setting `window.EmberENV = { _DEBUG_RENDER_TREE: true };`
+        before the "vendor" `<script>` tag in `index.html`.
+    
+        Setting the flag after Ember is already loaded will not work correctly. It
+        may appear to work somewhat, but fundamentally broken.
+    
+        This is not intended to be set directly. Ember Inspector will enable the
+        flag on behalf of the user as needed.
+    
+        This flag is always on in development mode.
+    
+        The flag is off by default in production mode, due to the cost associated
+        with the the bookkeeping work.
+    
+        The expected flow is that Ember Inspector will ask the user to refresh the
+        page after enabling the feature. It could also offer a feature where the
+        user add some domains to the "always on" list. In either case, Ember
+        Inspector will inject the code on the page to set the flag if needed.
+    
+        @property _DEBUG_RENDER_TREE
+        @for EmberENV
+        @type Boolean
+        @default false
+        @private
+      */
+      _DEBUG_RENDER_TREE: boolean;
+      /**
+        Whether the app defaults to using async observers.
+    
+        This is not intended to be set directly, as the implementation may change in
+        the future. Use `@ember/optional-features` instead.
+    
+        @property _DEFAULT_ASYNC_OBSERVERS
+        @for EmberENV
+        @type Boolean
+        @default false
+        @private
+      */
+      _DEFAULT_ASYNC_OBSERVERS: boolean;
+      /**
+        Controls the maximum number of scheduled rerenders without "settling". In general,
+        applications should not need to modify this environment variable, but please
+        open an issue so that we can determine if a better default value is needed.
+    
+        @property _RERENDER_LOOP_LIMIT
+        @for EmberENV
+        @type number
+        @default 1000
+        @private
+       */
+      _RERENDER_LOOP_LIMIT: number;
+      EMBER_LOAD_HOOKS: {
+          [hook: string]: Function[];
+      };
+      FEATURES: {
+          [feature: string]: boolean;
+      };
+  };
+  export function getENV(): object;
+}

package/types/stable/@ember/-internals/environment/lib/global.d.ts

@@ -0,0 +1,4 @@
+declare module '@ember/-internals/environment/lib/global.d.ts' {
+  const _default: any;
+  export default _default;
+}

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

@@ -0,0 +1,9 @@
+declare module '@ember/-internals/error-handling' {
+  export const onErrorTarget: {
+      readonly onerror: Function | undefined;
+  };
+  export function getOnerror(): Function | undefined;
+  export function setOnerror(handler: Function | undefined): void;
+  export function getDispatchOverride(): Function | null;
+  export function setDispatchOverride(handler: Function | null): void;
+}