@amcharts/amcharts4
Version:
amCharts 4
259 lines (258 loc) • 6.96 kB
TypeScript
/**
* ============================================================================
* IMPORTS
* ============================================================================
* @hidden
*/
import { IDisposer, Disposer } from "./Disposer";
import { EventDispatcher, AMEvent } from "./EventDispatcher";
import { Optional } from "./Type";
import { IClone } from "./Clone";
import * as $iter from "./Iterator";
/**
* Defines events from [[Dictionary]].
*/
export interface IDictionaryEvents<Key, Value> {
/**
* Invoked when an item is removed from the dictionary.
*/
removed: {
/**
* Removed value.
*/
oldValue: Value;
};
/**
* Invoked when dictionary is cleared.
*/
cleared: {};
/**
* Invoked when `insertKey()` method is called.
*/
insertKey: {
/**
* Key.
*/
key: Key;
/**
* Added value.
*/
newValue: Value;
};
/**
* Invoked when `setKey()` method is called.
*/
setKey: {
/**
* Key.
*/
key: Key;
/**
* Removed value. (if overwriting)
*/
oldValue: Value;
/**
* Added value.
*/
newValue: Value;
};
/**
* Invoked when `removeKey()` method is called.
*/
removeKey: {
/**
* Key.
*/
key: Key;
/**
* Removed value.
*/
oldValue: Value;
};
}
/**
* [K description]
*
* @ignore Exclude from docs
* @todo Descirption
*/
export declare type DictionaryLike<K, A> = $iter.Iterable<[K, A]> & {
events: EventDispatcher<{
removed: {
oldValue: A;
};
}>;
};
/**
* A disposable dictionary, which when disposed itself will call `dispose()`
* method on all its items.
*/
export declare class DictionaryDisposer<K, A extends IDisposer> extends Disposer {
constructor(dict: DictionaryLike<K, A>);
}
/**
* A Dictionary is collection where values of some type can be mapped to
* string keys.
*
* You might call it an "associative list" or "associative array".
*/
export declare class Dictionary<Key extends string, T> {
/**
* Key/value pairs
*/
private _dictionary;
/**
* Event dispatcher.
*/
events: EventDispatcher<AMEvent<Dictionary<Key, T>, IDictionaryEvents<Key, T>>>;
/**
* Constructor
*/
constructor();
/**
* Returns `true` if key exists in Dictionary.
*
* @param key The key to search for
* @return `true` if key exists, `false` if it doesn't
*/
hasKey(key: Key): boolean;
/**
* Returns the value for a specific key.
*
* @param key The key to search for
* @return Value for the key, or `undefined` if it doesn't exist
*/
getKey(key: Key): Optional<T>;
/**
* Inserts value at specific key.
*
* Will thrown an exception if the key already exists in the dictionary.
*
* @param key Key
* @param value Value
*/
insertKey(key: Key, value: T): void;
/**
* Adds or updates key/value into dictionary.
*
* If the key already exists, the old value will be overwritten.
*
* If the new value is exactly the same as the old value (using ===), it won't do anything.
*
* @param key Key
* @param value Value
*/
setKey(key: Key, value: T): void;
/**
* Updates the value at specific `key` using custom function.
*
* Passes in current value into the function, and uses its output as a new
* value.
*
* If the new value is exactly the same as the old value (using ===), it won't do anything.
*
* @ignore Exclude from docs
* @param key Key
* @param fn Function to transform the value
*/
updateKey(key: Key, fn: (value: T) => T): void;
/**
* Removes value at specific `key` from dictionary.
*
* @param key Key to remove
*/
removeKey(key: Key): void;
/**
* [insertKeyIfEmpty description]
*
* @ignore Exclude from docs
* @todo description
* @param key [description]
* @param ifEmpty [description]
* @return [description]
*/
insertKeyIfEmpty(key: Key, ifEmpty: () => T): T;
/**
* Removes all items from the dictionary.
*/
clear(): void;
/**
* Copies items from another Dictionary.
*
* @param source A Dictionary to copy items from
*/
copyFrom(source: this): void;
/**
* Returns an interator that can be used to iterate through all items in
* the dictionary.
*
* @return Iterator
*/
iterator(): $iter.Iterator<[Key, T]>;
/**
* Returns an ES6 iterator for the keys/values of the dictionary.
*/
[Symbol.iterator](): Iterator<[Key, T]>;
/**
* Calls `f` for each key/value in the dictionary.
*/
each(f: (key: Key, value: T) => void): void;
/**
* Returns an iterator that can be used to iterate through all items in
* the dictionary, ordered by key.
*
* @ignore Exclude from docs
* @return Iterator
*/
sortedIterator(): $iter.Iterator<[Key, T]>;
}
/**
* A version of a [[Dictionary]] that has a "template".
*
* A template is an instance of an object, that can be used to create new
* elements in the list without actually needing to create instances for those.
*
* When new element is created in the list, e.g. by calling its `create()`
* method, an exact copy of the element is created (including properties and
* other attributes), inserted into the list and returned.
*/
export declare class DictionaryTemplate<Key extends string, T extends IClone<T> & {
isTemplate: boolean;
}> extends Dictionary<Key, T> {
/**
* A template object.
*
* @todo Make this private
*/
_template: T;
/**
* Constructor
*
* @param t Template object
*/
constructor(t: T);
/**
* A "template" object to copy all properties from when creating new list
* items.
*
* @param v Template object
*/
/**
* @return Template object
*/
template: T;
/**
* Copies all elements from other dictionary.
*
* @param source Source dictionary
*/
copyFrom(source: this): void;
/**
* Instantiates a new object of the specified type, adds it to specified
* `key` in the dictionary, and returns it.
*
* @param make Item type to use. Will use the default type for the dictionary if not specified.
* @return Newly created item
*/
create(key: Key): T;
}