223 lines
8.8 KiB
TypeScript
223 lines
8.8 KiB
TypeScript
import Asset from './Asset';
|
|
import KnowledgeDatabase from './KnowledgeDatabase';
|
|
export declare type ErrCallback = (err) => void;
|
|
export declare type NodeConstructor = new (...args: any[]) => Node;
|
|
/** Knowledge Base document store object. This is where data lives.
|
|
* Nodes have edges which point to other nodes in any KB slice
|
|
* (possibly even slices not in your current model). Edges have names
|
|
* to group them into layers.
|
|
*
|
|
* All user specified data goes into `node.data`.
|
|
*
|
|
* `model.createNode()` is typically used to create new nodes so the
|
|
* nodes will be bound to a KB slice for saving.
|
|
*
|
|
* @class Node
|
|
* @memberof jibo.kb
|
|
* @param {string} [nodeType] Type of node. Defaults to 'node'.
|
|
* @param {Object} [data] Initial data.
|
|
* @param {Object} [cloneFrom] Object or node to clone from.
|
|
*/
|
|
export default class Node {
|
|
private static nodeClassRegistry;
|
|
_id: string;
|
|
type: string;
|
|
data: any;
|
|
created: number;
|
|
updated: number;
|
|
edges: {
|
|
[id: string]: string[];
|
|
};
|
|
assets: {
|
|
[id: string]: string[];
|
|
};
|
|
getKb: () => KnowledgeDatabase;
|
|
/** Register a Node subclass to be instantiated when a node of a
|
|
* given type is loaded or created.
|
|
*
|
|
* @method jibo.kb.Node.registerNodeClass
|
|
* @static
|
|
* @param {string|string[]} nodeType Node type to use this
|
|
* subclass for.
|
|
* @param {Function} classConstruction The constructor function
|
|
* for the subclass.
|
|
* @param {string} [kbName] Name of KB to limit the use
|
|
* of this subclass to. Defaults to all KBs.
|
|
* @internal
|
|
*/
|
|
static registerNodeClass(nodeType: string, classConstructor: NodeConstructor, kbName?: string): void;
|
|
/** Use the node type to find a Node subclass in the Node Class
|
|
* registry. Default to the plain `Node` object if nothing
|
|
* matches.
|
|
*
|
|
* @method jibo.kb.Node.findNodeClass
|
|
* @static
|
|
* @param {string} nodeType Type of node.
|
|
* @param {string} kbName Name of KB slice.
|
|
* @returns {Function} Node class constructor.
|
|
* @internal
|
|
*/
|
|
static findNodeClass(nodeType: string, kbName: string): NodeConstructor;
|
|
constructor(nodeType?: string, data?: any, cloneFrom?: any);
|
|
/** Save the node into KB slice it is bound to.
|
|
* Also sets the `node.updated` timestamp.
|
|
*
|
|
* @method jibo.kb.Node#save
|
|
* @param {Function} [callback] Called when node is finished
|
|
* saving. If callback is omitted a promise is returned instead.
|
|
* @returns {Promise} A promise if the callback is omitted.
|
|
*/
|
|
save(callback: ErrCallback): any;
|
|
save(): Promise<any>;
|
|
/** Remove the node from KB slice it is bound to.
|
|
*
|
|
* @method jibo.kb.Node#remove
|
|
* @param {Function} [callback] Called when node is finished being
|
|
* removed. If callback is omitted a promise is returned instead.
|
|
* @returns {Promise} A promise if the callback is omitted.
|
|
*/
|
|
remove(callback: ErrCallback): any;
|
|
remove(): Promise<any>;
|
|
/** Add edges to this node. Edges will have the name given by
|
|
* layer, or will be taken from the node types (but nodes must be
|
|
* given in that case, no id strings).
|
|
*
|
|
* @method jibo.kb.Node#addEdges
|
|
* @param {string|jibo.kb.Node|string[]|jibo.kb.Node[]} idsOrNodes Ids of edges to
|
|
* add to this node. Ids will be gotten from any nodes provided.
|
|
* @param {string} [layer] Added edges will have this name. If
|
|
* Nodes are given and layer is not specified, the edge name will
|
|
* be taken from the node type.
|
|
*/
|
|
addEdges(idsOrNodes: string | string[] | Node | Node[], layer?: string): void;
|
|
/** Remove edges of the given layer name from this node. Layer can
|
|
* be omitted if nodes are given and the node types match the
|
|
* layer names of the edges to be removed.
|
|
*
|
|
* @method jibo.kb.Node#removeEdges
|
|
* @param {string|jibo.kb.Node|string[]|jibo.kb.Node[]} idsOrNodes Ids of edges to
|
|
* remove from this node. Ids will be gotten from any nodes
|
|
* provided.
|
|
* @param {string} [layer] Remove edges with this name. If Nodes
|
|
* are given and layer is not specified, the edge name will be
|
|
* taken from the node type for each node id.
|
|
*/
|
|
removeEdges(idsOrNodes: string | string[] | Node | Node[], layer?: string): void;
|
|
/** Remove all edges of a given name.
|
|
*
|
|
* @method jibo.kb.Node#clearEdges
|
|
* @param {string|string[]} layers The layer names (edge names) to remove.
|
|
*/
|
|
clearEdges(layers: string | string[]): void;
|
|
/** Get edges of given layer names. Duplicates are removed (this
|
|
* may change). Order of edges are preserved for a single layer
|
|
* name (except for duplicate removal). Order gets even messier for
|
|
* multiple layers (because of duplicate removal).
|
|
*
|
|
* @method jibo.kb.Node#getEdges
|
|
* @param {string|string[]} layers Nmes of layers to return edges for.
|
|
* @returns {string[]} Array of IDs.
|
|
*/
|
|
getEdges(layers: string | string[]): string[];
|
|
/** All layers (edge names) on this node
|
|
* @method jibo.kb.Node#getLayers
|
|
* @returns {string[]} Array of layer names.
|
|
*/
|
|
getLayers(): string[];
|
|
/** Create a new asset object and add it to the list of assets on
|
|
* this node.
|
|
*
|
|
* @method jibo.kb.Node#createAsset
|
|
* @param {string} [subtype] Subtype name for this asset.
|
|
* @param {string} [ext] Optional filename extension.
|
|
* @returns {jibo.kb.Asset} New asset object.
|
|
*/
|
|
createAsset(subtype?: string, ext?: string): Asset;
|
|
/** Add existing asset objects to the list of assets on this
|
|
* node. The asset objects root directory needs to match this node
|
|
* object.
|
|
*
|
|
* @method jibo.kb.Node#addAssets
|
|
* @param {jibo.kb.Asset|jibo.kb.Asset[]} assets Asset objects to add to node.
|
|
* @param {string} [subtype] Subtype string to force assets to be
|
|
* added as. Subtype comes from each asset object unless this is
|
|
* specified.
|
|
*/
|
|
addAssets(assets: Asset | Asset[], subtype?: string): void;
|
|
/** Get all asset objects of given subtype from the assets listed
|
|
* on this node.
|
|
*
|
|
* @method jibo.kb.Node#getAssets
|
|
* @param {string} [subtype] Asset subtype to get. Defaults to `asset`.
|
|
* @returns {jibo.kb.Asset[]} Array of asset objects.
|
|
*/
|
|
getAssets(subtype?: string): Asset[];
|
|
/** Get all asset objects from the assets listed on this node,
|
|
* regardless of subtype.
|
|
*
|
|
* @method jibo.kb.Node#getAllAssets
|
|
* @returns {jibo.kb.Asset[]} Array of asset objects.
|
|
*/
|
|
getAllAssets(): Asset[];
|
|
/** List of all asset subtypes on this node.
|
|
*
|
|
* @method jibo.kb.Node#getAssetSubtypes
|
|
* @returns {string[]} Array of subtype name strings.
|
|
*/
|
|
getAssetSubtypes(): string[];
|
|
/** Delete an asset from disk and remove it from this node.
|
|
*
|
|
* @method jibo.kb.Node#removeAsset
|
|
* @param {jibo.kb.Asset} asset Asset object to remove.
|
|
* @param {Function} [callback] Called when done. If callback is
|
|
* omitted a promise is returned instead.
|
|
* @returns {Promise} A promise if the callback is omitted.
|
|
*/
|
|
removeAsset(asset: Asset, callback: ErrCallback): any;
|
|
removeAsset(asset: Asset): Promise<any>;
|
|
/** Delete from disk and remove all assets from the node.
|
|
*
|
|
* @method jibo.kb.Node#removeAllAssets
|
|
* @param {Function} [callback] Called when done. If callback is
|
|
* omitted a promise is returned instead.
|
|
* @returns {Promise} A promise if the callback is omitted.
|
|
*/
|
|
removeAllAssets(callback: ErrCallback): any;
|
|
removeAllAssets(): Promise<any>;
|
|
/** Bind this node to a given KB slice.
|
|
*
|
|
* @method jibo.kb.Node#setKb
|
|
* @param {jibo.kb.KnowledgeDatabase} knowledgeDatabase KB "slice" to bind this node to
|
|
* @returns {jibo.kb.Node} `this`
|
|
* @internal
|
|
*/
|
|
setKb(knowledgeDatabase: KnowledgeDatabase): this;
|
|
/** Set the 'updated' timestamp on this node.
|
|
*
|
|
* @method jibo.kb.Node#setUpdated
|
|
* @param {number} [timestamp] Milliseconds since 1 January 1970
|
|
* 00:00:00 UTC. Defaults to now.
|
|
*/
|
|
setUpdated(timestamp?: number): void;
|
|
/** Decide if a given item is an id string or a node. If it is a
|
|
* node, extract the id, and set the layer to the node type if
|
|
* layer wasn't specified.
|
|
*
|
|
* @method jibo.kb.Node#_resolveIdAndLayer
|
|
* @param {string|jibo.kb.Node} idOrNode
|
|
* @param {string} [layer] User supplied layer name or undefined/null
|
|
* @param {string} methodName Name of calling method just for error reporting.
|
|
* @param {Object} {id, layer}
|
|
* @private
|
|
* @internal
|
|
*/
|
|
private _resolveIdAndLayer(idOrNode, layer, methodName);
|
|
/** Convert a single item to an array for arguments that may be a
|
|
* single thing or an array of things
|
|
*
|
|
* @method jibo.kb.Node#_toArray
|
|
* @private
|
|
*/
|
|
private _toArray<T>(items);
|
|
}
|