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

package/types/stable/@ember/debug/data-adapter.d.ts

@@ -0,0 +1,325 @@
+declare module '@ember/debug/data-adapter.d.ts' {
+  import type Owner from '@ember/owner';
+  import type { NativeArray } from '@ember/array';
+  import EmberObject from '@ember/object';
+  import type ContainerDebugAdapter from '@ember/debug/container-debug-adapter';
+  /**
+  @module @ember/debug/data-adapter
+  */
+  type RecordColor = 'black' | 'red' | 'blue' | 'green';
+  type WrappedType<N extends string = string> = {
+      name: N;
+      count: number;
+      columns: unknown[];
+      object: unknown;
+  };
+  type WrappedRecord<T> = {
+      object: T;
+      columnValues: object;
+      searchKeywords: NativeArray<unknown>;
+      filterValues: object;
+      color: RecordColor | null;
+  };
+  type RecordCallback<T> = (records: Array<{
+      columnValues: object;
+      object: T;
+  }>) => void;
+  /**
+    The `DataAdapter` helps a data persistence library
+    interface with tools that debug Ember such
+    as the [Ember Inspector](https://github.com/emberjs/ember-inspector)
+    for Chrome and Firefox.
+
+    This class will be extended by a persistence library
+    which will override some of the methods with
+    library-specific code.
+
+    The methods likely to be overridden are:
+
+    * `getFilters`
+    * `detect`
+    * `columnsForType`
+    * `getRecords`
+    * `getRecordColumnValues`
+    * `getRecordKeywords`
+    * `getRecordFilterValues`
+    * `getRecordColor`
+
+    The adapter will need to be registered
+    in the application's container as `dataAdapter:main`.
+
+    Example:
+
+    ```javascript
+    Application.initializer({
+      name: "data-adapter",
+
+      initialize: function(application) {
+        application.register('data-adapter:main', DS.DataAdapter);
+      }
+    });
+    ```
+
+    @class DataAdapter
+    @extends EmberObject
+    @public
+  */
+  export default class DataAdapter<T> extends EmberObject {
+      releaseMethods: NativeArray<() => void>;
+      recordsWatchers: Map<unknown, {
+          release: () => void;
+          revalidate: () => void;
+      }>;
+      typeWatchers: Map<unknown, {
+          release: () => void;
+          revalidate: () => void;
+      }>;
+      flushWatchers: (() => void) | null;
+      containerDebugAdapter: ContainerDebugAdapter;
+      constructor(owner: Owner);
+      /**
+        The container-debug-adapter which is used
+        to list all models.
+    
+        @property containerDebugAdapter
+        @default undefined
+        @since 1.5.0
+        @public
+      **/
+      /**
+        The number of attributes to send
+        as columns. (Enough to make the record
+        identifiable).
+    
+        @private
+        @property attributeLimit
+        @default 3
+        @since 1.3.0
+      */
+      attributeLimit: number;
+      /**
+         Ember Data > v1.0.0-beta.18
+         requires string model names to be passed
+         around instead of the actual factories.
+    
+         This is a stamp for the Ember Inspector
+         to differentiate between the versions
+         to be able to support older versions too.
+    
+         @public
+         @property acceptsModelName
+       */
+      acceptsModelName: boolean;
+      /**
+         Map from records arrays to RecordsWatcher instances
+    
+         @private
+         @property recordsWatchers
+         @since 3.26.0
+       */
+      /**
+        Map from records arrays to TypeWatcher instances
+    
+        @private
+        @property typeWatchers
+        @since 3.26.0
+       */
+      /**
+        Callback that is currently scheduled on backburner end to flush and check
+        all active watchers.
+    
+        @private
+        @property flushWatchers
+        @since 3.26.0
+    
+       */
+      /**
+        Stores all methods that clear observers.
+        These methods will be called on destruction.
+    
+        @private
+        @property releaseMethods
+        @since 1.3.0
+      */
+      /**
+        Specifies how records can be filtered.
+        Records returned will need to have a `filterValues`
+        property with a key for every name in the returned array.
+    
+        @public
+        @method getFilters
+        @return {Array} List of objects defining filters.
+         The object should have a `name` and `desc` property.
+      */
+      getFilters(): NativeArray<unknown>;
+      /**
+        Fetch the model types and observe them for changes.
+    
+        @public
+        @method watchModelTypes
+    
+        @param {Function} typesAdded Callback to call to add types.
+        Takes an array of objects containing wrapped types (returned from `wrapModelType`).
+    
+        @param {Function} typesUpdated Callback to call when a type has changed.
+        Takes an array of objects containing wrapped types.
+    
+        @return {Function} Method to call to remove all observers
+      */
+      watchModelTypes(typesAdded: (types: WrappedType[]) => void, typesUpdated: (types: WrappedType[]) => void): () => void;
+      _nameToClass(type: unknown): unknown;
+      /**
+        Fetch the records of a given type and observe them for changes.
+    
+        @public
+        @method watchRecords
+    
+        @param {String} modelName The model name.
+    
+        @param {Function} recordsAdded Callback to call to add records.
+        Takes an array of objects containing wrapped records.
+        The object should have the following properties:
+          columnValues: {Object} The key and value of a table cell.
+          object: {Object} The actual record object.
+    
+        @param {Function} recordsUpdated Callback to call when a record has changed.
+        Takes an array of objects containing wrapped records.
+    
+        @param {Function} recordsRemoved Callback to call when a record has removed.
+        Takes an array of objects containing wrapped records.
+    
+        @return {Function} Method to call to remove all observers.
+      */
+      watchRecords(modelName: string, recordsAdded: RecordCallback<T>, recordsUpdated: RecordCallback<T>, recordsRemoved: RecordCallback<T>): () => void;
+      updateFlushWatchers(): void;
+      /**
+        Clear all observers before destruction
+        @private
+        @method willDestroy
+      */
+      willDestroy(): void;
+      /**
+        Detect whether a class is a model.
+    
+        Test that against the model class
+        of your persistence library.
+    
+        @public
+        @method detect
+        @return boolean Whether the class is a model class or not.
+      */
+      detect(_klass: unknown): boolean;
+      /**
+        Get the columns for a given model type.
+    
+        @public
+        @method columnsForType
+        @return {Array} An array of columns of the following format:
+         name: {String} The name of the column.
+         desc: {String} Humanized description (what would show in a table column name).
+      */
+      columnsForType(_klass: unknown): NativeArray<unknown>;
+      /**
+        Adds observers to a model type class.
+    
+        @private
+        @method observeModelType
+        @param {String} modelName The model type name.
+        @param {Function} typesUpdated Called when a type is modified.
+        @return {Function} The function to call to remove observers.
+      */
+      observeModelType(modelName: string, typesUpdated: (types: WrappedType[]) => void): () => void;
+      /**
+        Wraps a given model type and observes changes to it.
+    
+        @private
+        @method wrapModelType
+        @param {Class} klass A model class.
+        @param {String} modelName Name of the class.
+        @return {Object} The wrapped type has the following format:
+          name: {String} The name of the type.
+          count: {Integer} The number of records available.
+          columns: {Columns} An array of columns to describe the record.
+          object: {Class} The actual Model type class.
+      */
+      wrapModelType<N extends string>(klass: unknown, name: N): WrappedType<N>;
+      /**
+        Fetches all models defined in the application.
+    
+        @private
+        @method getModelTypes
+        @return {Array} Array of model types.
+      */
+      getModelTypes(): Array<{
+          klass: unknown;
+          name: string;
+      }>;
+      /**
+        Loops over all namespaces and all objects
+        attached to them.
+    
+        @private
+        @method _getObjectsOnNamespaces
+        @return {Array} Array of model type strings.
+      */
+      _getObjectsOnNamespaces(): string[];
+      /**
+        Fetches all loaded records for a given type.
+    
+        @public
+        @method getRecords
+        @return {Array} An array of records.
+         This array will be observed for changes,
+         so it should update when new records are added/removed.
+      */
+      getRecords(_klass: unknown, _name: string): NativeArray<T>;
+      /**
+        Wraps a record and observers changes to it.
+    
+        @private
+        @method wrapRecord
+        @param {Object} record The record instance.
+        @return {Object} The wrapped record. Format:
+        columnValues: {Array}
+        searchKeywords: {Array}
+      */
+      wrapRecord(record: T): WrappedRecord<T>;
+      /**
+        Gets the values for each column.
+    
+        @public
+        @method getRecordColumnValues
+        @return {Object} Keys should match column names defined
+        by the model type.
+      */
+      getRecordColumnValues(_record: T): {};
+      /**
+        Returns keywords to match when searching records.
+    
+        @public
+        @method getRecordKeywords
+        @return {Array} Relevant keywords for search.
+      */
+      getRecordKeywords(_record: T): NativeArray<unknown>;
+      /**
+        Returns the values of filters defined by `getFilters`.
+    
+        @public
+        @method getRecordFilterValues
+        @param {Object} record The record instance.
+        @return {Object} The filter values.
+      */
+      getRecordFilterValues(_record: T): object;
+      /**
+        Each record can have a color that represents its state.
+    
+        @public
+        @method getRecordColor
+        @param {Object} record The record instance
+        @return {String} The records color.
+          Possible options: black, red, blue, green.
+      */
+      getRecordColor(_record: T): RecordColor | null;
+  }
+  export {};
+}

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

@@ -0,0 +1,52 @@
+declare module '@ember/debug' {
+  import type { DeprecateFunc, DeprecationOptions } from './lib/deprecate';
+  import type { WarnFunc } from './lib/warn';
+  export { registerHandler as registerWarnHandler } from './lib/warn';
+  export { registerHandler as registerDeprecationHandler, DeprecationOptions } from './lib/deprecate';
+  export { default as inspect } from './lib/inspect';
+  export { isTesting, setTesting } from './lib/testing';
+  export { default as captureRenderTree } from './lib/capture-render-tree';
+  export type DebugFunctionType = 'assert' | 'info' | 'warn' | 'debug' | 'deprecate' | 'debugSeal' | 'debugFreeze' | 'runInDebug' | 'deprecateFunc';
+  export type AssertFunc = (desc: string, condition?: unknown) => asserts condition;
+  export type DebugFunc = (message: string) => void;
+  export type DebugSealFunc = (obj: object) => void;
+  export type DebugFreezeFunc = (obj: object) => void;
+  export type InfoFunc = (message: string, options?: object) => void;
+  export type RunInDebugFunc = (func: () => void) => void;
+  export type DeprecateFuncFunc = (message: string, options: DeprecationOptions, func: Function) => Function;
+  export type GetDebugFunction = {
+      (type: 'assert'): AssertFunc;
+      (type: 'info'): InfoFunc;
+      (type: 'warn'): WarnFunc;
+      (type: 'debug'): DebugFunc;
+      (type: 'debugSeal'): DebugSealFunc;
+      (type: 'debugFreeze'): DebugFreezeFunc;
+      (type: 'deprecateFunc'): DeprecateFuncFunc;
+      (type: 'deprecate'): DeprecateFunc;
+      (type: 'runInDebug'): RunInDebugFunc;
+  };
+  export type SetDebugFunction = {
+      (type: 'assert', func: AssertFunc): AssertFunc;
+      (type: 'info', func: InfoFunc): InfoFunc;
+      (type: 'warn', func: WarnFunc): WarnFunc;
+      (type: 'debug', func: DebugFunc): DebugFunc;
+      (type: 'debugSeal', func: DebugSealFunc): DebugSealFunc;
+      (type: 'debugFreeze', func: DebugFreezeFunc): DebugFreezeFunc;
+      (type: 'deprecateFunc', func: DeprecateFuncFunc): DeprecateFuncFunc;
+      (type: 'deprecate', func: DeprecateFunc): DeprecateFunc;
+      (type: 'runInDebug', func: RunInDebugFunc): RunInDebugFunc;
+  };
+  let assert: AssertFunc;
+  let info: InfoFunc;
+  let warn: WarnFunc;
+  let debug: DebugFunc;
+  let deprecate: DeprecateFunc;
+  let debugSeal: DebugSealFunc;
+  let debugFreeze: DebugFreezeFunc;
+  let runInDebug: RunInDebugFunc;
+  let setDebugFunction: SetDebugFunction;
+  let getDebugFunction: GetDebugFunction;
+  let deprecateFunc: DeprecateFuncFunc;
+  let _warnIfUsingStrippedFeatureFlags: any;
+  export { assert, info, warn, debug, deprecate, debugSeal, debugFreeze, runInDebug, deprecateFunc, setDebugFunction, getDebugFunction, _warnIfUsingStrippedFeatureFlags, };
+}

package/types/stable/@ember/debug/lib/capture-render-tree.d.ts

@@ -0,0 +1,21 @@
+declare module '@ember/debug/lib/capture-render-tree.d.ts' {
+  import type Owner from '@ember/owner';
+  import type { CapturedRenderNode } from '@glimmer/interfaces';
+  /**
+    @module @ember/debug
+  */
+  /**
+    Ember Inspector calls this function to capture the current render tree.
+
+    In production mode, this requires turning on `ENV._DEBUG_RENDER_TREE`
+    before loading Ember.
+
+    @private
+    @static
+    @method captureRenderTree
+    @for @ember/debug
+    @param app {ApplicationInstance} An `ApplicationInstance`.
+    @since 3.14.0
+  */
+  export default function captureRenderTree(app: Owner): CapturedRenderNode[];
+}

package/types/stable/@ember/debug/lib/deprecate.d.ts

@@ -0,0 +1,72 @@
+declare module '@ember/debug/lib/deprecate.d.ts' {
+  import type { HandlerCallback } from './handlers';
+  global {
+      const __fail__: {
+          fail(): void;
+      };
+  }
+  interface Available {
+      available: string;
+  }
+  interface Enabled extends Available {
+      enabled: string;
+  }
+  export interface DeprecationOptions {
+      id: string;
+      until: string;
+      url?: string;
+      for: string;
+      since: Available | Enabled;
+  }
+  export type DeprecateFunc = (message: string, test?: boolean, options?: DeprecationOptions) => void;
+  export type MissingOptionDeprecateFunc = (id: string, missingOption: string) => string;
+  /**
+   @module @ember/debug
+   @public
+  */
+  /**
+    Allows for runtime registration of handler functions that override the default deprecation behavior.
+    Deprecations are invoked by calls to [@ember/debug/deprecate](/ember/release/classes/@ember%2Fdebug/methods/deprecate?anchor=deprecate).
+    The following example demonstrates its usage by registering a handler that throws an error if the
+    message contains the word "should", otherwise defers to the default handler.
+
+    ```javascript
+    import { registerDeprecationHandler } from '@ember/debug';
+
+    registerDeprecationHandler((message, options, next) => {
+      if (message.indexOf('should') !== -1) {
+        throw new Error(`Deprecation message with should: ${message}`);
+      } else {
+        // defer to whatever handler was registered before this one
+        next(message, options);
+      }
+    });
+    ```
+
+    The handler function takes the following arguments:
+
+    <ul>
+      <li> <code>message</code> - The message received from the deprecation call.</li>
+      <li> <code>options</code> - An object passed in with the deprecation call containing additional information including:</li>
+        <ul>
+          <li> <code>id</code> - An id of the deprecation in the form of <code>package-name.specific-deprecation</code>.</li>
+          <li> <code>until</code> - The Ember version number the feature and deprecation will be removed in.</li>
+        </ul>
+      <li> <code>next</code> - A function that calls into the previously registered handler.</li>
+    </ul>
+
+    @public
+    @static
+    @method registerDeprecationHandler
+    @for @ember/debug
+    @param handler {Function} A function to handle deprecation calls.
+    @since 2.1.0
+  */
+  let registerHandler: (handler: HandlerCallback<DeprecationOptions>) => void;
+  let missingOptionsDeprecation: string;
+  let missingOptionsIdDeprecation: string;
+  let missingOptionDeprecation: MissingOptionDeprecateFunc;
+  let deprecate: DeprecateFunc;
+  export default deprecate;
+  export { registerHandler, missingOptionsDeprecation, missingOptionsIdDeprecation, missingOptionDeprecation, };
+}

package/types/stable/@ember/debug/lib/handlers.d.ts

@@ -0,0 +1,14 @@
+declare module '@ember/debug/lib/handlers.d.ts' {
+  export type Options = object;
+  export type Handler<O extends Options> = (message: string, options?: O) => void;
+  export type HandlerCallback<O extends Options> = (message: string, options: O | undefined, nextHandler: Handler<O>) => void;
+  export interface Handlers {
+      [key: string]: Handler<Options>;
+  }
+  export let HANDLERS: Handlers;
+  export type RegisterHandlerFunc<O extends Options> = (type: string, callback: HandlerCallback<O>) => void;
+  export type InvokeFunc = (type: string, message: string, test?: boolean, options?: Options) => void;
+  let registerHandler: <O extends object>(_type: string, _callback: HandlerCallback<O>) => void;
+  let invoke: InvokeFunc;
+  export { registerHandler, invoke };
+}

package/types/stable/@ember/debug/lib/inspect.d.ts

@@ -0,0 +1,20 @@
+declare module '@ember/debug/lib/inspect.d.ts' {
+  /**
+   @module @ember/debug
+  */
+  /**
+    Convenience method to inspect an object. This method will attempt to
+    convert the object into a useful string description.
+
+    It is a pretty simple implementation. If you want something more robust,
+    use something like JSDump: https://github.com/NV/jsDump
+
+    @method inspect
+    @static
+    @param {Object} obj The object you want to inspect.
+    @return {String} A description of the object
+    @since 1.4.0
+    @private
+  */
+  export default function inspect(this: any, obj: any | null | undefined): string;
+}

package/types/stable/@ember/debug/lib/testing.d.ts

@@ -0,0 +1,4 @@
+declare module '@ember/debug/lib/testing.d.ts' {
+  export function isTesting(): boolean;
+  export function setTesting(value: boolean): void;
+}

package/types/stable/@ember/debug/lib/warn.d.ts

@@ -0,0 +1,14 @@
+declare module '@ember/debug/lib/warn.d.ts' {
+  import type { HandlerCallback } from './handlers';
+  export interface WarnOptions {
+      id: string;
+  }
+  export type RegisterHandlerFunc = (handler: HandlerCallback<WarnOptions>) => void;
+  export type WarnFunc = (message: string, test?: boolean, options?: WarnOptions) => void;
+  let registerHandler: RegisterHandlerFunc;
+  let warn: WarnFunc;
+  let missingOptionsDeprecation: string;
+  let missingOptionsIdDeprecation: string;
+  export default warn;
+  export { registerHandler, missingOptionsIdDeprecation, missingOptionsDeprecation };
+}

package/types/stable/@ember/deprecated-features/index.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/deprecated-features' {
+  export const ASSIGN = true;
+}