typescript-closure-tools
Version:
Command-line tools to convert closure-style JSDoc annotations to typescript, and to convert typescript sources to closure externs files
374 lines (317 loc) • 13.4 kB
TypeScript
/// <reference path="../../../globals.d.ts" />
/// <reference path="../log/log.d.ts" />
declare module goog.ds {
class DataNode extends DataNode__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class DataNode__Class {
/**
* Interface for node in rich data tree.
*
* Names that are reserved for system use and shouldn't be used for data node
* names: eval, toSource, toString, unwatch, valueOf, watch. Behavior is
* undefined if these names are used.
*
* @constructor
*/
constructor();
/**
* Get the value of the node
* @param {...?} var_args Do not check arity of arguments, because
* some subclasses require args.
* @return {*} The value of the node, or null if no value.
*/
get(...var_args: any[]): any;
/**
* Set the value of the node
* @param {*} value The new value of the node.
*/
set(value: any): void;
/**
* Gets all of the child nodes of the current node.
* Should return an empty DataNode list if no child nodes.
* @param {string=} opt_selector String selector to choose child nodes.
* @return {!goog.ds.DataNodeList} The child nodes.
*/
getChildNodes(opt_selector?: string): goog.ds.DataNodeList;
/**
* Gets a named child node of the current node
* @param {string} name The node name.
* @param {boolean=} opt_canCreate Whether to create a child node if it does not
* exist.
* @return {goog.ds.DataNode} The child node, or null
* if no node of this name exists.
*/
getChildNode(name: string, opt_canCreate?: boolean): goog.ds.DataNode;
/**
* Gets the value of a child node
* @param {string} name The node name.
* @return {*} The value of the node, or null if no value or the child node
* doesn't exist.
*/
getChildNodeValue(name: string): any;
/**
* Sets a named child node of the current node.
*
* @param {string} name The node name.
* @param {Object} value The value to set, can be DataNode, object, property,
* or null. If value is null, removes the child node.
* @return {Object} The child node, if the node was set.
*/
setChildNode(name: string, value: Object): Object;
/**
* Get the name of the node relative to the parent node
* @return {string} The name of the node.
*/
getDataName(): string;
/**
* Set the name of the node relative to the parent node
* @param {string} name The name of the node.
*/
setDataName(name: string): void;
/**
* Gets the a qualified data path to this node
* @return {string} The data path.
*/
getDataPath(): string;
/**
* Load or reload the backing data for this node
*/
load: any /*missing*/;
/**
* Gets the state of the backing data for this node
* @return {goog.ds.LoadState} The state.
*/
getLoadState(): goog.ds.LoadState;
/**
* Whether the value of this node is a homogeneous list of data
* @return {boolean} True if a list.
*/
isList(): boolean;
}
class BaseDataNode extends BaseDataNode__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class BaseDataNode__Class {
/**
* Base class for data node functionality, has default implementations for
* many of the functions.
*
* implements {goog.ds.DataNode}
* @constructor
*/
constructor();
/**
* Set the value of the node
* @param {Object} value The new value of the node.
*/
set(value: Object): void;
/**
* Gets all of the child nodes of the current node.
* Should return an empty DataNode list if no child nodes.
* @param {string=} opt_selector String selector to choose child nodes.
* @return {!goog.ds.DataNodeList} The child nodes.
*/
getChildNodes(opt_selector?: string): goog.ds.DataNodeList;
/**
* Gets a named child node of the current node
* @param {string} name The node name.
* @param {boolean=} opt_canCreate Whether you can create the child node if
* it doesn't exist already.
* @return {goog.ds.DataNode} The child node, or null if no node of
* this name exists and opt_create is false.
*/
getChildNode(name: string, opt_canCreate?: boolean): goog.ds.DataNode;
/**
* Gets the value of a child node
* @param {string} name The node name.
* @return {Object} The value of the node, or null if no value or the
* child node doesn't exist.
*/
getChildNodeValue(name: string): Object;
/**
* Get the name of the node relative to the parent node
* @return {string} The name of the node.
*/
getDataName(): string;
/**
* Gets the a qualified data path to this node
* @return {string} The data path.
*/
getDataPath(): string;
/**
* Load or reload the backing data for this node
*/
load: any /*missing*/;
/**
* Gets the state of the backing data for this node
* @return {goog.ds.LoadState} The state.
*/
getLoadState(): goog.ds.LoadState;
/**
* Gets the parent node. Subclasses implement this function
* @type {Function}
* @protected
*/
getParent: Function;
}
class DataNodeList extends DataNodeList__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class DataNodeList__Class extends goog.ds.DataNode__Class {
/**
* Interface for node list in rich data tree.
*
* Has both map and list-style accessors
*
* @constructor
* @extends {goog.ds.DataNode}
*/
constructor();
/**
* Add a node to the node list.
* If the node has a dataName, uses this for the key in the map.
*
* @param {goog.ds.DataNode} node The node to add.
*/
add(node: goog.ds.DataNode): void;
/**
* Get a node by index
* Returns null if the index is out of range
*
* @param {number} index The index of the node.
* @return {goog.ds.DataNode} The node, or null if doesn't exist.
*/
getByIndex(index: number): goog.ds.DataNode;
/**
* Gets the size of the node list
*
* @return {number} The size of the list.
*/
getCount(): number;
/**
* Sets a node in the list of a given name
* @param {string} name Name of the node.
* @param {goog.ds.DataNode} node The node.
*/
setNode(name: string, node: goog.ds.DataNode): void;
/**
* Removes a node in the list of a given name
* @param {string} name Name of the node.
* @return {boolean} True if node existed and was deleted.
*/
removeNode(name: string): boolean;
}
class BasicNodeList extends BasicNodeList__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class BasicNodeList__Class extends goog.ds.DataNodeList__Class {
/**
* Simple node list implementation with underlying array and map
* implements goog.ds.DataNodeList.
*
* Names that are reserved for system use and shouldn't be used for data node
* names: eval, toSource, toString, unwatch, valueOf, watch. Behavior is
* undefined if these names are used.
*
* @param {Array.<goog.ds.DataNode>=} opt_nodes optional nodes to add to list.
* @constructor
* @extends {goog.ds.DataNodeList}
*/
constructor(opt_nodes?: goog.ds.DataNode[]);
/**
* Get the index of a named node
* @param {string} name The name of the node to get the index of.
* @return {number|undefined} The index.
*/
indexOf(name: string): number|any /*undefined*/;
}
class EmptyNodeList extends EmptyNodeList__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class EmptyNodeList__Class extends goog.ds.BasicNodeList__Class {
/**
* Immulatable empty node list
* @extends {goog.ds.BasicNodeList}
* @constructor
* @final
*/
constructor();
}
class SortedNodeList extends SortedNodeList__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class SortedNodeList__Class extends goog.ds.BasicNodeList__Class {
/**
* Node list implementation which maintains sort order during insertion and
* modification operations based on a comparison function.
*
* The SortedNodeList does not guarantee sort order will be maintained if
* the underlying data nodes are modified externally.
*
* Names that are reserved for system use and shouldn't be used for data node
* names: eval, toSource, toString, unwatch, valueOf, watch. Behavior is
* undefined if these names are used.
*
* @param {Function} compareFn Comparison function by which the
* node list is sorted. Should take 2 arguments to compare, and return a
* negative integer, zero, or a positive integer depending on whether the
* first argument is less than, equal to, or greater than the second.
* @param {Array.<goog.ds.DataNode>=} opt_nodes optional nodes to add to list;
* these are assumed to be in sorted order.
* @extends {goog.ds.BasicNodeList}
* @constructor
*/
constructor(compareFn: Function, opt_nodes?: goog.ds.DataNode[]);
/**
* Adds the given node to the end of the SortedNodeList. This should
* only be used when the caller can guarantee that the sort order will
* be maintained according to this SortedNodeList's compareFn (e.g.
* when initializing a new SortedNodeList from a list of nodes that has
* already been sorted).
* @param {goog.ds.DataNode} node The node to append.
*/
append(node: goog.ds.DataNode): void;
}
/**
* Enum for load state of a DataNode.
* @enum {string}
*/
enum LoadState { LOADED, LOADING, FAILED, NOT_LOADED }
/**
* The character denoting an attribute.
* @type {string}
*/
var STR_ATTRIBUTE_START: string;
/**
* The character denoting all children.
* @type {string}
*/
var STR_ALL_CHILDREN_SELECTOR: string;
/**
* The wildcard character.
* @type {string}
*/
var STR_WILDCARD: string;
/**
* The character denoting path separation.
* @type {string}
*/
var STR_PATH_SEPARATOR: string;
/**
* The character denoting the start of an array.
* @type {string}
*/
var STR_ARRAY_START: string;
/**
* Shared logger instance for data package
* @type {goog.log.Logger}
*/
var logger: goog.log.Logger;
}
declare module goog.ds.Util {
/**
* Create a data node that references another data node,
* useful for pointer-like functionality.
* All functions will return same values as the original node except for
* getDataName()
* @param {!goog.ds.DataNode} node The original node.
* @param {string} name The new name.
* @return {!goog.ds.DataNode} The new data node.
*/
function makeReferenceNode(node: goog.ds.DataNode, name: string): goog.ds.DataNode;
}