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> },
> = ...

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>;
} = ...

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>;
    },
> = ...

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>;
    },
> = ...

graphTemplateEvents

graphTemplateEvents: {
    nameChanged: BaklavaEvent<string, GraphTemplate>;
    updated: BaklavaEvent<void, GraphTemplate>;
} & ISubscribableProxy<
    {
        nameChanged: BaklavaEvent<string, GraphTemplate>;
        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,
        >;
    },
> = ...

hooks

hooks: {
load: SequentialHook<IEditorState, Editor, IEditorState>;
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>;
    },
> = ...

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>,
        >;
    },
> = ...

Accessors

graph

get graph(): Graph
The root graph

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

graphs

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

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

graphTemplates

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

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

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: GraphTemplate): void
Parameters
- template: GraphTemplate
Returns void
- Defined in core/src/editor.ts:124

load

load(state: IEditorState): 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: Graph): void
Parameters
- graph: Graph
Returns void
- Defined in core/src/editor.ts:162

registerNodeType

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

removeGraphTemplate

removeGraphTemplate(template: GraphTemplate): 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: Graph): void
Parameters
- graph: Graph
Returns void
- Defined in core/src/editor.ts:173

unregisterNodeType

unregisterNodeType(type: string | AbstractNodeConstructor): 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

events

graphEvents

graphHooks

graphTemplateEvents

graphTemplateHooks

hooks

nodeEvents

nodeHooks

Accessors

graph

Returns Graph

graphs

Returns ReadonlySet<Graph>

graphTemplates

Returns readonly GraphTemplate[]

loading

Returns boolean

nodeTypes

Returns ReadonlyMap<string, INodeTypeInformation>

Methods

addGraphTemplate

Parameters

Returns void

load

Parameters

Returns string[]

registerGraph

Parameters

Returns void

registerNodeType

Parameters

Returns void

removeGraphTemplate

Parameters

Returns void

save

Returns IEditorState

unregisterGraph

Parameters

Returns void

unregisterNodeType

Parameters

Returns void

Settings

On This Page