Class Editor

The main model class for BaklavaJS

Implements

IBaklavaEventEmitter
IBaklavaTapable

Index

Constructors

constructor

new Editor(): Editor
Returns Editor
- Defined in core/src/editor.ts:86

Properties

connectionEvents

connectionEvents: {
destruct: BaklavaEvent<void, Connection>;
} & ISubscribableProxy<{
destruct: BaklavaEvent<void, Connection>;
}> = ...

Type declaration

Readonly destruct: BaklavaEvent<void, Connection>

events

events: {
    addGraphTemplate: BaklavaEvent<GraphTemplate, Editor>;
    beforeAddGraphTemplate: PreventableBaklavaEvent<GraphTemplate, Editor>;
    beforeRegisterNodeType: PreventableBaklavaEvent<IAddNodeTypeEventData, Editor>;
    beforeRemoveGraphTemplate: PreventableBaklavaEvent<GraphTemplate, Editor>;
    beforeUnregisterNodeType: PreventableBaklavaEvent<string, Editor>;
    loaded: BaklavaEvent<void, Editor>;
    registerGraph: BaklavaEvent<Graph, Editor>;
    registerNodeType: BaklavaEvent<IAddNodeTypeEventData, Editor>;
    removeGraphTemplate: BaklavaEvent<GraphTemplate, Editor>;
    unregisterGraph: BaklavaEvent<Graph, Editor>;
    unregisterNodeType: BaklavaEvent<string, Editor>;
} = ...

Type declaration

Readonly addGraphTemplate: BaklavaEvent<GraphTemplate, Editor>
Readonly beforeAddGraphTemplate: PreventableBaklavaEvent<GraphTemplate, Editor>
Readonly beforeRegisterNodeType: PreventableBaklavaEvent<IAddNodeTypeEventData, Editor>
Readonly beforeRemoveGraphTemplate: PreventableBaklavaEvent<GraphTemplate, Editor>
Readonly beforeUnregisterNodeType: PreventableBaklavaEvent<string, Editor>
Readonly loaded: BaklavaEvent<void, Editor>
Readonly registerGraph: BaklavaEvent<Graph, Editor>
Readonly registerNodeType: BaklavaEvent<IAddNodeTypeEventData, Editor>
Readonly removeGraphTemplate: BaklavaEvent<GraphTemplate, Editor>
Readonly unregisterGraph: BaklavaEvent<Graph, Editor>
Readonly unregisterNodeType: BaklavaEvent<string, Editor>

graphEvents

graphEvents: {
    addConnection: BaklavaEvent<IConnection, Graph>;
    addNode: BaklavaEvent<AbstractNode, Graph>;
    beforeAddConnection: PreventableBaklavaEvent<IAddConnectionEventData, Graph>;
    beforeAddNode: PreventableBaklavaEvent<AbstractNode, Graph>;
    beforeRemoveConnection: PreventableBaklavaEvent<IConnection, Graph>;
    beforeRemoveNode: PreventableBaklavaEvent<AbstractNode, Graph>;
    checkConnection: PreventableBaklavaEvent<IAddConnectionEventData, Graph>;
    removeConnection: BaklavaEvent<IConnection, Graph>;
    removeNode: BaklavaEvent<AbstractNode, Graph>;
} & ISubscribableProxy<{
    addConnection: BaklavaEvent<IConnection, Graph>;
    addNode: BaklavaEvent<AbstractNode, Graph>;
    beforeAddConnection: PreventableBaklavaEvent<IAddConnectionEventData, Graph>;
    beforeAddNode: PreventableBaklavaEvent<AbstractNode, Graph>;
    beforeRemoveConnection: PreventableBaklavaEvent<IConnection, Graph>;
    beforeRemoveNode: PreventableBaklavaEvent<AbstractNode, Graph>;
    checkConnection: PreventableBaklavaEvent<IAddConnectionEventData, Graph>;
    removeConnection: BaklavaEvent<IConnection, Graph>;
    removeNode: BaklavaEvent<AbstractNode, Graph>;
}> = ...

Type declaration

Readonly addConnection: BaklavaEvent<IConnection, Graph>
Readonly addNode: BaklavaEvent<AbstractNode, Graph>
Readonly beforeAddConnection: PreventableBaklavaEvent<IAddConnectionEventData, Graph>
Readonly beforeAddNode: PreventableBaklavaEvent<AbstractNode, Graph>
Readonly beforeRemoveConnection: PreventableBaklavaEvent<IConnection, Graph>
Readonly beforeRemoveNode: PreventableBaklavaEvent<AbstractNode, Graph>
Readonly checkConnection: PreventableBaklavaEvent<IAddConnectionEventData, Graph>
Readonly removeConnection: BaklavaEvent<IConnection, Graph>
Readonly removeNode: BaklavaEvent<AbstractNode, Graph>

graphHooks

graphHooks: {
    checkConnection: ParallelHook<IAddConnectionEventData, CheckConnectionHookResult, Graph>;
    load: SequentialHook<IGraphState, Graph, IGraphState>;
    save: SequentialHook<IGraphState, Graph, IGraphState>;
} & ISubscribableProxy<{
    checkConnection: ParallelHook<IAddConnectionEventData, CheckConnectionHookResult, Graph>;
    load: SequentialHook<IGraphState, Graph, IGraphState>;
    save: SequentialHook<IGraphState, Graph, IGraphState>;
}> = ...

Type declaration

Readonly checkConnection: ParallelHook<IAddConnectionEventData, CheckConnectionHookResult, Graph>
Readonly load: SequentialHook<IGraphState, Graph, IGraphState>
Readonly save: SequentialHook<IGraphState, Graph, IGraphState>

graphTemplateEvents

graphTemplateEvents: {
    nameChanged: BaklavaEvent<string, GraphTemplate>;
    updated: BaklavaEvent<void, GraphTemplate>;
} & ISubscribableProxy<{
    nameChanged: BaklavaEvent<string, GraphTemplate>;
    updated: BaklavaEvent<void, GraphTemplate>;
}> = ...

Type declaration

Readonly nameChanged: BaklavaEvent<string, GraphTemplate>
Readonly updated: BaklavaEvent<void, GraphTemplate>

graphTemplateHooks

graphTemplateHooks: {
    afterSave: SequentialHook<IGraphTemplateState, GraphTemplate, IGraphTemplateState>;
    beforeLoad: SequentialHook<IGraphTemplateState, GraphTemplate, IGraphTemplateState>;
} & ISubscribableProxy<{
    afterSave: SequentialHook<IGraphTemplateState, GraphTemplate, IGraphTemplateState>;
    beforeLoad: SequentialHook<IGraphTemplateState, GraphTemplate, IGraphTemplateState>;
}> = ...

Type declaration

Readonly afterSave: SequentialHook<IGraphTemplateState, GraphTemplate, IGraphTemplateState>
Readonly beforeLoad: SequentialHook<IGraphTemplateState, GraphTemplate, IGraphTemplateState>

hooks

hooks: {
load: SequentialHook<IEditorState, Editor, IEditorState>;
save: SequentialHook<IEditorState, Editor, IEditorState>;
} = ...

Type declaration

Readonly load: SequentialHook<IEditorState, Editor, IEditorState>
Readonly save: SequentialHook<IEditorState, Editor, IEditorState>

nodeEvents

nodeEvents: {
    addInput: BaklavaEvent<NodeInterface<any>, AbstractNode>;
    addOutput: BaklavaEvent<NodeInterface<any>, AbstractNode>;
    beforeAddInput: PreventableBaklavaEvent<NodeInterface<any>, AbstractNode>;
    beforeAddOutput: PreventableBaklavaEvent<NodeInterface<any>, AbstractNode>;
    beforeRemoveInput: PreventableBaklavaEvent<NodeInterface<any>, AbstractNode>;
    beforeRemoveOutput: PreventableBaklavaEvent<NodeInterface<any>, AbstractNode>;
    beforeTitleChanged: PreventableBaklavaEvent<string, AbstractNode>;
    loaded: BaklavaEvent<AbstractNode, AbstractNode>;
    removeInput: BaklavaEvent<NodeInterface<any>, AbstractNode>;
    removeOutput: BaklavaEvent<NodeInterface<any>, AbstractNode>;
    titleChanged: BaklavaEvent<string, AbstractNode>;
    update: BaklavaEvent<null | INodeUpdateEventData, AbstractNode>;
} & ISubscribableProxy<{
    addInput: BaklavaEvent<NodeInterface<any>, AbstractNode>;
    addOutput: BaklavaEvent<NodeInterface<any>, AbstractNode>;
    beforeAddInput: PreventableBaklavaEvent<NodeInterface<any>, AbstractNode>;
    beforeAddOutput: PreventableBaklavaEvent<NodeInterface<any>, AbstractNode>;
    beforeRemoveInput: PreventableBaklavaEvent<NodeInterface<any>, AbstractNode>;
    beforeRemoveOutput: PreventableBaklavaEvent<NodeInterface<any>, AbstractNode>;
    beforeTitleChanged: PreventableBaklavaEvent<string, AbstractNode>;
    loaded: BaklavaEvent<AbstractNode, AbstractNode>;
    removeInput: BaklavaEvent<NodeInterface<any>, AbstractNode>;
    removeOutput: BaklavaEvent<NodeInterface<any>, AbstractNode>;
    titleChanged: BaklavaEvent<string, AbstractNode>;
    update: BaklavaEvent<null | INodeUpdateEventData, AbstractNode>;
}> = ...

Type declaration

Readonly addInput: BaklavaEvent<NodeInterface<any>, AbstractNode>
Readonly addOutput: BaklavaEvent<NodeInterface<any>, AbstractNode>
Readonly beforeAddInput: PreventableBaklavaEvent<NodeInterface<any>, AbstractNode>
Readonly beforeAddOutput: PreventableBaklavaEvent<NodeInterface<any>, AbstractNode>
Readonly beforeRemoveInput: PreventableBaklavaEvent<NodeInterface<any>, AbstractNode>
Readonly beforeRemoveOutput: PreventableBaklavaEvent<NodeInterface<any>, AbstractNode>
Readonly beforeTitleChanged: PreventableBaklavaEvent<string, AbstractNode>
Readonly loaded: BaklavaEvent<AbstractNode, AbstractNode>
Readonly removeInput: BaklavaEvent<NodeInterface<any>, AbstractNode>
Readonly removeOutput: BaklavaEvent<NodeInterface<any>, AbstractNode>
Readonly titleChanged: BaklavaEvent<string, AbstractNode>
Readonly update: BaklavaEvent<null | INodeUpdateEventData, AbstractNode>

nodeHooks

nodeHooks: {
    afterSave: SequentialHook<INodeState<any, any>, AbstractNode, INodeState<any, any>>;
    beforeLoad: SequentialHook<INodeState<any, any>, AbstractNode, INodeState<any, any>>;
} & ISubscribableProxy<{
    afterSave: SequentialHook<INodeState<any, any>, AbstractNode, INodeState<any, any>>;
    beforeLoad: SequentialHook<INodeState<any, any>, AbstractNode, INodeState<any, any>>;
}> = ...

Type declaration

Readonly afterSave: SequentialHook<INodeState<any, any>, AbstractNode, INodeState<any, any>>
Readonly beforeLoad: SequentialHook<INodeState<any, any>, AbstractNode, INodeState<any, any>>

Accessors

graph

get graph(): Graph
The root graph

Returns Graph
- Defined in core/src/editor.ts:67

graphTemplates

get graphTemplates(): readonly GraphTemplate[]
List of all registered graph templates (subgraphs)

Returns readonly GraphTemplate[]
- Defined in core/src/editor.ts:72

graphs

get graphs(): ReadonlySet<Graph>
Set of all graphs in the editor, including subgraphs

Returns ReadonlySet<Graph>
- Defined in core/src/editor.ts:77

loading

get loading(): boolean
Whether the editor is currently in the process of loading a saved graph

Returns boolean
- Defined in core/src/editor.ts:82

nodeTypes

get nodeTypes(): ReadonlyMap<string, INodeTypeInformation>
List of all registered node types

Returns ReadonlyMap<string, INodeTypeInformation>
- Defined in core/src/editor.ts:62

Methods

addGraphTemplate

addGraphTemplate(template): void
Parameters
- template: GraphTemplate
Returns void
- Defined in core/src/editor.ts:124

load

load(state): string[]
Load a state
Parameters
- state: IEditorState
  State to load
Returns string[]
An array of warnings that occured during loading. If the array is empty, the state was successfully loaded.
- Defined in core/src/editor.ts:189

registerGraph

registerGraph(graph): void
Parameters
- graph: Graph
Returns void
- Defined in core/src/editor.ts:162

registerNodeType

registerNodeType(type, options?): void
Register a new node type
Parameters
- type: AbstractNodeConstructor
  Actual type / constructor of the node
- Optional options: IRegisterNodeTypeOptions
  Optionally specify a title and/or a category for this node
Returns void
- Defined in core/src/editor.ts:96

removeGraphTemplate

removeGraphTemplate(template): void
Parameters
- template: GraphTemplate
Returns void
- Defined in core/src/editor.ts:138

save

save(): IEditorState
Save a state

Returns IEditorState
Current state
- Defined in core/src/editor.ts:218

unregisterGraph

unregisterGraph(graph): void
Parameters
- graph: Graph
Returns void
- Defined in core/src/editor.ts:173

unregisterNodeType

unregisterNodeType(type): void
Unregister an existing node type. Will also remove all the nodes of this type in all graphs.
Parameters
- type: string | AbstractNodeConstructor
  String type or node constructor, from which the type will be detected
Returns void
- Defined in core/src/editor.ts:113

Class Editor

Implements

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Returns Editor

Properties

connectionEvents

Type declaration

Readonly destruct: BaklavaEvent<void, Connection>

events

Type declaration

Readonly addGraphTemplate: BaklavaEvent<GraphTemplate, Editor>

Readonly beforeAddGraphTemplate: PreventableBaklavaEvent<GraphTemplate, Editor>

Readonly beforeRegisterNodeType: PreventableBaklavaEvent<IAddNodeTypeEventData, Editor>

Readonly beforeRemoveGraphTemplate: PreventableBaklavaEvent<GraphTemplate, Editor>

Readonly beforeUnregisterNodeType: PreventableBaklavaEvent<string, Editor>

Readonly loaded: BaklavaEvent<void, Editor>

Readonly registerGraph: BaklavaEvent<Graph, Editor>

Readonly registerNodeType: BaklavaEvent<IAddNodeTypeEventData, Editor>

Readonly removeGraphTemplate: BaklavaEvent<GraphTemplate, Editor>

Readonly unregisterGraph: BaklavaEvent<Graph, Editor>

Readonly unregisterNodeType: BaklavaEvent<string, Editor>

graphEvents

Type declaration

Readonly addConnection: BaklavaEvent<IConnection, Graph>

Readonly addNode: BaklavaEvent<AbstractNode, Graph>

Readonly beforeAddConnection: PreventableBaklavaEvent<IAddConnectionEventData, Graph>

Readonly beforeAddNode: PreventableBaklavaEvent<AbstractNode, Graph>

Readonly beforeRemoveConnection: PreventableBaklavaEvent<IConnection, Graph>

Readonly beforeRemoveNode: PreventableBaklavaEvent<AbstractNode, Graph>

Readonly checkConnection: PreventableBaklavaEvent<IAddConnectionEventData, Graph>

Readonly removeConnection: BaklavaEvent<IConnection, Graph>

Readonly removeNode: BaklavaEvent<AbstractNode, Graph>

graphHooks

Type declaration

Readonly checkConnection: ParallelHook<IAddConnectionEventData, CheckConnectionHookResult, Graph>

Readonly load: SequentialHook<IGraphState, Graph, IGraphState>

Readonly save: SequentialHook<IGraphState, Graph, IGraphState>

graphTemplateEvents

Type declaration

Readonly nameChanged: BaklavaEvent<string, GraphTemplate>

Readonly updated: BaklavaEvent<void, GraphTemplate>

graphTemplateHooks

Type declaration

Readonly afterSave: SequentialHook<IGraphTemplateState, GraphTemplate, IGraphTemplateState>

Readonly beforeLoad: SequentialHook<IGraphTemplateState, GraphTemplate, IGraphTemplateState>

hooks

Type declaration

Readonly load: SequentialHook<IEditorState, Editor, IEditorState>

Readonly save: SequentialHook<IEditorState, Editor, IEditorState>

nodeEvents

Type declaration

Readonly addInput: BaklavaEvent<NodeInterface<any>, AbstractNode>

Readonly addOutput: BaklavaEvent<NodeInterface<any>, AbstractNode>

Readonly beforeAddInput: PreventableBaklavaEvent<NodeInterface<any>, AbstractNode>

Readonly beforeAddOutput: PreventableBaklavaEvent<NodeInterface<any>, AbstractNode>

Readonly beforeRemoveInput: PreventableBaklavaEvent<NodeInterface<any>, AbstractNode>

Readonly beforeRemoveOutput: PreventableBaklavaEvent<NodeInterface<any>, AbstractNode>

Readonly beforeTitleChanged: PreventableBaklavaEvent<string, AbstractNode>

Readonly loaded: BaklavaEvent<AbstractNode, AbstractNode>

Readonly removeInput: BaklavaEvent<NodeInterface<any>, AbstractNode>

Readonly removeOutput: BaklavaEvent<NodeInterface<any>, AbstractNode>

Readonly titleChanged: BaklavaEvent<string, AbstractNode>

Readonly update: BaklavaEvent<null | INodeUpdateEventData, AbstractNode>

nodeHooks

Type declaration

Readonly afterSave: SequentialHook<INodeState<any, any>, AbstractNode, INodeState<any, any>>

Readonly beforeLoad: SequentialHook<INodeState<any, any>, AbstractNode, INodeState<any, any>>

Accessors

graph

Returns Graph

graphTemplates

Returns readonly GraphTemplate[]

graphs

Returns ReadonlySet<Graph>

`Readonly` destruct: BaklavaEvent<void, Connection>

`Readonly` addGraphTemplate: BaklavaEvent<GraphTemplate, Editor>

`Readonly` beforeAddGraphTemplate: PreventableBaklavaEvent<GraphTemplate, Editor>

`Readonly` beforeRegisterNodeType: PreventableBaklavaEvent<IAddNodeTypeEventData, Editor>

`Readonly` beforeRemoveGraphTemplate: PreventableBaklavaEvent<GraphTemplate, Editor>

`Readonly` beforeUnregisterNodeType: PreventableBaklavaEvent<string, Editor>

`Readonly` loaded: BaklavaEvent<void, Editor>

`Readonly` registerGraph: BaklavaEvent<Graph, Editor>

`Readonly` registerNodeType: BaklavaEvent<IAddNodeTypeEventData, Editor>

`Readonly` removeGraphTemplate: BaklavaEvent<GraphTemplate, Editor>

`Readonly` unregisterGraph: BaklavaEvent<Graph, Editor>

`Readonly` unregisterNodeType: BaklavaEvent<string, Editor>

`Readonly` addConnection: BaklavaEvent<IConnection, Graph>

`Readonly` addNode: BaklavaEvent<AbstractNode, Graph>

`Readonly` beforeAddConnection: PreventableBaklavaEvent<IAddConnectionEventData, Graph>

`Readonly` beforeAddNode: PreventableBaklavaEvent<AbstractNode, Graph>

`Readonly` beforeRemoveConnection: PreventableBaklavaEvent<IConnection, Graph>

`Readonly` beforeRemoveNode: PreventableBaklavaEvent<AbstractNode, Graph>

`Readonly` checkConnection: PreventableBaklavaEvent<IAddConnectionEventData, Graph>

`Readonly` removeConnection: BaklavaEvent<IConnection, Graph>

`Readonly` removeNode: BaklavaEvent<AbstractNode, Graph>

`Readonly` checkConnection: ParallelHook<IAddConnectionEventData, CheckConnectionHookResult, Graph>

`Readonly` load: SequentialHook<IGraphState, Graph, IGraphState>

`Readonly` save: SequentialHook<IGraphState, Graph, IGraphState>

`Readonly` nameChanged: BaklavaEvent<string, GraphTemplate>

`Readonly` updated: BaklavaEvent<void, GraphTemplate>

`Readonly` afterSave: SequentialHook<IGraphTemplateState, GraphTemplate, IGraphTemplateState>

`Readonly` beforeLoad: SequentialHook<IGraphTemplateState, GraphTemplate, IGraphTemplateState>

`Readonly` load: SequentialHook<IEditorState, Editor, IEditorState>

`Readonly` save: SequentialHook<IEditorState, Editor, IEditorState>

`Readonly` addInput: BaklavaEvent<NodeInterface<any>, AbstractNode>

`Readonly` addOutput: BaklavaEvent<NodeInterface<any>, AbstractNode>

`Readonly` beforeAddInput: PreventableBaklavaEvent<NodeInterface<any>, AbstractNode>

`Readonly` beforeAddOutput: PreventableBaklavaEvent<NodeInterface<any>, AbstractNode>

`Readonly` beforeRemoveInput: PreventableBaklavaEvent<NodeInterface<any>, AbstractNode>

`Readonly` beforeRemoveOutput: PreventableBaklavaEvent<NodeInterface<any>, AbstractNode>

`Readonly` beforeTitleChanged: PreventableBaklavaEvent<string, AbstractNode>

`Readonly` loaded: BaklavaEvent<AbstractNode, AbstractNode>

`Readonly` removeInput: BaklavaEvent<NodeInterface<any>, AbstractNode>

`Readonly` removeOutput: BaklavaEvent<NodeInterface<any>, AbstractNode>

`Readonly` titleChanged: BaklavaEvent<string, AbstractNode>

`Readonly` update: BaklavaEvent<null | INodeUpdateEventData, AbstractNode>

`Readonly` afterSave: SequentialHook<INodeState<any, any>, AbstractNode, INodeState<any, any>>

`Readonly` beforeLoad: SequentialHook<INodeState<any, any>, AbstractNode, INodeState<any, any>>