ember-source
Version:
A JavaScript framework for creating ambitious web applications
332 lines (291 loc) • 10.9 kB
TypeScript
declare module '@ember/debug/data-adapter' {
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 Column = {
name: string;
desc: string;
};
type WrappedType<N extends string = string> = {
name: N;
count: number;
columns: Column[];
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(): Array<{
name: string;
desc: string;
}>;
/**
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): Column[];
/**
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 {};
}