babylonjs-node-editor 5.32.1 → 5.33.0

package/babylon.nodeEditor.d.ts

@@ -1623,7 +1623,7 @@ declare module BABYLON.NodeEditor.SharedUIComponents {
      * @param row
      * @returns
      */
-    export const getPosInLayout: (layout: BABYLON.NodeEditor.SharedUIComponents.Layout, column: number, row?: number | undefined) => LayoutColumn;
+    export const getPosInLayout: (layout: BABYLON.NodeEditor.SharedUIComponents.Layout, column: number, row?: number | undefined) => BABYLON.NodeEditor.SharedUIComponents.LayoutColumn | BABYLON.NodeEditor.SharedUIComponents.LayoutTabsRow;
     /**
      * Remove a row in position row, column from the layout, and redistribute heights of remaining rows
      * @param layout
@@ -1823,6 +1823,285 @@ declare module BABYLON.NodeEditor.SharedUIComponents {
 
 
 
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        /**
+     * Props for the connector
+     */
+    export interface IGraphConnectorHandlerProps {
+        /**
+         * id of the parent node
+         */
+        parentId: string;
+        /**
+         * x position of the parent node
+         */
+        parentX: number;
+        /**
+         * y position of the parent node
+         */
+        parentY: number;
+        /**
+         * x position of the connector relative to the parent node
+         */
+        offsetX?: number;
+        /**
+         * y position of the connector relative to the parent node
+         */
+        offsetY?: number;
+        /**
+         * width of the parent node
+         */
+        parentWidth: number;
+        /**
+         * height of the parent node
+         */
+        parentHeight: number;
+        /**
+         * id of the container where its parent node is
+         */
+        parentContainerId: string;
+    }
+    /**
+     * This component is used to initiate a connection between two nodes. Simply
+     * drag the handle in a node and drop it in another node to create a connection.
+     */
+    export var GraphConnectorHandler: React.FC<IGraphConnectorHandlerProps>;
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export interface IGraphContainerProps {
+    }
+    /**
+     * This component is just a simple container to keep the nodes and lines containers
+     * together
+     * @param props
+     * @returns
+     */
+    export var GraphContainer: React.FC<IGraphContainerProps>;
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        /// <reference types="react" />
+    /**
+     * this context is used to pass callbacks to the graph nodes and connections
+     */
+    export interface IGraphContext {
+        onNodesConnected?: (sourceId: string, targetId: string) => void;
+        onLineSelected?: (lineId: string) => void;
+        onNodeSelected?: (nodeId: string) => void;
+    }
+    export var GraphContextManager: import("react").Context<IGraphContext>;
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        /**
+     * props for the GraphLine component
+     */
+    export interface IGraphLineProps {
+        /**
+         * id of the line. temporary lines can have no id
+         */
+        id?: string;
+        /**
+         * starting x pos of the line
+         */
+        x1: number;
+        /**
+         * ending x pos of the line
+         */
+        x2: number;
+        /**
+         * starting y pos of the line
+         */
+        y1: number;
+        /**
+         * ending y pos of the line
+         */
+        y2: number;
+        /**
+         * is the line selected
+         */
+        selected?: boolean;
+        /**
+         * does the line have a direction
+         */
+        directional?: boolean;
+    }
+    export const MarkerArrowId = "arrow";
+    /**
+     * This component draws a SVG line between two points, with an optional marker
+     * indicating direction
+     */
+    export var GraphLine: React.FC<IGraphLineProps>;
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        /**
+     * props for the GraphLineContainer
+     */
+    export interface IGraphLinesContainerProps {
+        /**
+         * id of the container
+         */
+        id: string;
+    }
+    /**
+     * this component handles the dragging of new connections
+     * @param props
+     * @returns
+     */
+    export var GraphLinesContainer: React.FC<IGraphLinesContainerProps>;
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export interface IGraphNodeProps {
+        id: string;
+        name: string;
+        x: number;
+        y: number;
+        selected?: boolean;
+        width?: number;
+        height?: number;
+        highlighted?: boolean;
+        parentContainerId: string;
+    }
+    export var GraphNode: React.FC<IGraphNodeProps>;
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export interface IGraphContainerProps {
+        onNodeMoved: (id: string, x: number, y: number) => void;
+        id: string;
+    }
+    /**
+     * This component contains all the nodes and handles their dragging
+     */
+    export var GraphNodesContainer: React.FC<IGraphContainerProps>;
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export type IVisualRecordsType = Record<string, {
+        x: number;
+        y: number;
+    }>;
+    export type IConnectionType = {
+        id: string;
+        sourceId: string;
+        targetId: string;
+    };
+    export type ICustomDataType = {
+        type: string;
+        value: any;
+    };
+    export type INodeType = {
+        id: string;
+        label: string;
+        customData?: ICustomDataType;
+    };
+    /**
+     * props for the node renderer
+     */
+    export interface INodeRendererProps {
+        /**
+         * array of connections between nodes
+         */
+        connections: IConnectionType[];
+        /**
+         * function called when a new connection is created
+         */
+        updateConnections: (sourceId: string, targetId: string) => void;
+        /**
+         * function called when a connection is deleted
+         */
+        deleteLine: (lineId: string) => void;
+        /**
+         * function called when a node is deleted
+         */
+        deleteNode: (nodeId: string) => void;
+        /**
+         * array of all nodes
+         */
+        nodes: INodeType[];
+        /**
+         * id of the node to highlight
+         */
+        highlightedNode?: BABYLON.Nullable<string>;
+        /**
+         * function to be called if a node is selected
+         */
+        selectNode?: (nodeId: BABYLON.Nullable<string>) => void;
+        /**
+         * id of this renderer
+         */
+        id: string;
+        /**
+         * optional list of custom components to be rendered inside nodes of
+         * a certain type
+         */
+        customComponents?: Record<string, React.ComponentType<any>>;
+    }
+    /**
+     * This component is a bridge between the app logic related to the graph, and the actual rendering
+     * of it. It manages the nodes' positions and selection states.
+     * @param props
+     * @returns
+     */
+    export const NodeRenderer: (props: INodeRendererProps) => JSX.Element;
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        /**
+     * utility hook to assist using the graph context
+     * @returns
+     */
+    export const useGraphContext: () => IGraphContext;
+
+
+
 }
 declare module BABYLON.NodeEditor {
 

package/babylon.nodeEditor.module.d.ts

@@ -1893,7 +1893,7 @@ export enum ResizeDirections {
 
 }
 declare module "babylonjs-node-editor/components/layout/utils" {
-import { Layout } from "babylonjs-node-editor/components/layout/types";
+import { Layout, LayoutColumn, LayoutTabsRow } from "babylonjs-node-editor/components/layout/types";
 /**
  * Given a column and row number in the layout, return the corresponding column/row
  * @param layout
@@ -1901,7 +1901,7 @@ import { Layout } from "babylonjs-node-editor/components/layout/types";
  * @param row
  * @returns
  */
-export const getPosInLayout: (layout: Layout, column: number, row?: number | undefined) => import("babylonjs-node-editor/components/layout/types").LayoutTabsRow | import("./types").LayoutColumn;
+export const getPosInLayout: (layout: Layout, column: number, row?: number | undefined) => LayoutColumn | LayoutTabsRow;
 /**
  * Remove a row in position row, column from the layout, and redistribute heights of remaining rows
  * @param layout
@@ -2084,6 +2084,248 @@ export interface MessageDialogProps {
 }
 export const MessageDialog: React.FC<MessageDialogProps>;
 
+}
+declare module "babylonjs-node-editor/components/reactGraphSystem/GraphConnectorHandle" {
+import { FC } from "react";
+/**
+ * Props for the connector
+ */
+export interface IGraphConnectorHandlerProps {
+    /**
+     * id of the parent node
+     */
+    parentId: string;
+    /**
+     * x position of the parent node
+     */
+    parentX: number;
+    /**
+     * y position of the parent node
+     */
+    parentY: number;
+    /**
+     * x position of the connector relative to the parent node
+     */
+    offsetX?: number;
+    /**
+     * y position of the connector relative to the parent node
+     */
+    offsetY?: number;
+    /**
+     * width of the parent node
+     */
+    parentWidth: number;
+    /**
+     * height of the parent node
+     */
+    parentHeight: number;
+    /**
+     * id of the container where its parent node is
+     */
+    parentContainerId: string;
+}
+/**
+ * This component is used to initiate a connection between two nodes. Simply
+ * drag the handle in a node and drop it in another node to create a connection.
+ */
+export const GraphConnectorHandler: FC<IGraphConnectorHandlerProps>;
+
+}
+declare module "babylonjs-node-editor/components/reactGraphSystem/GraphContainer" {
+import { FC } from "react";
+export interface IGraphContainerProps {
+}
+/**
+ * This component is just a simple container to keep the nodes and lines containers
+ * together
+ * @param props
+ * @returns
+ */
+export const GraphContainer: FC<IGraphContainerProps>;
+
+}
+declare module "babylonjs-node-editor/components/reactGraphSystem/GraphContextManager" {
+/// <reference types="react" />
+/**
+ * this context is used to pass callbacks to the graph nodes and connections
+ */
+export interface IGraphContext {
+    onNodesConnected?: (sourceId: string, targetId: string) => void;
+    onLineSelected?: (lineId: string) => void;
+    onNodeSelected?: (nodeId: string) => void;
+}
+export const GraphContextManager: import("react").Context<IGraphContext>;
+
+}
+declare module "babylonjs-node-editor/components/reactGraphSystem/GraphLine" {
+import { FC } from "react";
+/**
+ * props for the GraphLine component
+ */
+export interface IGraphLineProps {
+    /**
+     * id of the line. temporary lines can have no id
+     */
+    id?: string;
+    /**
+     * starting x pos of the line
+     */
+    x1: number;
+    /**
+     * ending x pos of the line
+     */
+    x2: number;
+    /**
+     * starting y pos of the line
+     */
+    y1: number;
+    /**
+     * ending y pos of the line
+     */
+    y2: number;
+    /**
+     * is the line selected
+     */
+    selected?: boolean;
+    /**
+     * does the line have a direction
+     */
+    directional?: boolean;
+}
+export const MarkerArrowId = "arrow";
+/**
+ * This component draws a SVG line between two points, with an optional marker
+ * indicating direction
+ */
+export const GraphLine: FC<IGraphLineProps>;
+
+}
+declare module "babylonjs-node-editor/components/reactGraphSystem/GraphLinesContainer" {
+import { FC } from "react";
+/**
+ * props for the GraphLineContainer
+ */
+export interface IGraphLinesContainerProps {
+    /**
+     * id of the container
+     */
+    id: string;
+}
+/**
+ * this component handles the dragging of new connections
+ * @param props
+ * @returns
+ */
+export const GraphLinesContainer: FC<IGraphLinesContainerProps>;
+
+}
+declare module "babylonjs-node-editor/components/reactGraphSystem/GraphNode" {
+import { FC } from "react";
+export interface IGraphNodeProps {
+    id: string;
+    name: string;
+    x: number;
+    y: number;
+    selected?: boolean;
+    width?: number;
+    height?: number;
+    highlighted?: boolean;
+    parentContainerId: string;
+}
+export const GraphNode: FC<IGraphNodeProps>;
+
+}
+declare module "babylonjs-node-editor/components/reactGraphSystem/GraphNodesContainer" {
+import { FC } from "react";
+export interface IGraphContainerProps {
+    onNodeMoved: (id: string, x: number, y: number) => void;
+    id: string;
+}
+/**
+ * This component contains all the nodes and handles their dragging
+ */
+export const GraphNodesContainer: FC<IGraphContainerProps>;
+
+}
+declare module "babylonjs-node-editor/components/reactGraphSystem/NodeRenderer" {
+import { ComponentType } from "react";
+import { Nullable } from "babylonjs/types";
+export type IVisualRecordsType = Record<string, {
+    x: number;
+    y: number;
+}>;
+export type IConnectionType = {
+    id: string;
+    sourceId: string;
+    targetId: string;
+};
+export type ICustomDataType = {
+    type: string;
+    value: any;
+};
+export type INodeType = {
+    id: string;
+    label: string;
+    customData?: ICustomDataType;
+};
+/**
+ * props for the node renderer
+ */
+export interface INodeRendererProps {
+    /**
+     * array of connections between nodes
+     */
+    connections: IConnectionType[];
+    /**
+     * function called when a new connection is created
+     */
+    updateConnections: (sourceId: string, targetId: string) => void;
+    /**
+     * function called when a connection is deleted
+     */
+    deleteLine: (lineId: string) => void;
+    /**
+     * function called when a node is deleted
+     */
+    deleteNode: (nodeId: string) => void;
+    /**
+     * array of all nodes
+     */
+    nodes: INodeType[];
+    /**
+     * id of the node to highlight
+     */
+    highlightedNode?: Nullable<string>;
+    /**
+     * function to be called if a node is selected
+     */
+    selectNode?: (nodeId: Nullable<string>) => void;
+    /**
+     * id of this renderer
+     */
+    id: string;
+    /**
+     * optional list of custom components to be rendered inside nodes of
+     * a certain type
+     */
+    customComponents?: Record<string, ComponentType<any>>;
+}
+/**
+ * This component is a bridge between the app logic related to the graph, and the actual rendering
+ * of it. It manages the nodes' positions and selection states.
+ * @param props
+ * @returns
+ */
+export const NodeRenderer: (props: INodeRendererProps) => JSX.Element;
+
+}
+declare module "babylonjs-node-editor/components/reactGraphSystem/useGraphContext" {
+/**
+ * utility hook to assist using the graph context
+ * @returns
+ */
+export const useGraphContext: () => import("babylonjs-node-editor/components/reactGraphSystem/GraphContextManager").IGraphContext;
+
 }
 declare module "babylonjs-node-editor/components/TextInputWithSubmit" {
 /// <reference types="react" />
@@ -5640,7 +5882,7 @@ declare module BABYLON.NodeEditor.SharedUIComponents {
      * @param row
      * @returns
      */
-    export const getPosInLayout: (layout: BABYLON.NodeEditor.SharedUIComponents.Layout, column: number, row?: number | undefined) => LayoutColumn;
+    export const getPosInLayout: (layout: BABYLON.NodeEditor.SharedUIComponents.Layout, column: number, row?: number | undefined) => BABYLON.NodeEditor.SharedUIComponents.LayoutColumn | BABYLON.NodeEditor.SharedUIComponents.LayoutTabsRow;
     /**
      * Remove a row in position row, column from the layout, and redistribute heights of remaining rows
      * @param layout
@@ -5840,6 +6082,285 @@ declare module BABYLON.NodeEditor.SharedUIComponents {
 
 
 
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        /**
+     * Props for the connector
+     */
+    export interface IGraphConnectorHandlerProps {
+        /**
+         * id of the parent node
+         */
+        parentId: string;
+        /**
+         * x position of the parent node
+         */
+        parentX: number;
+        /**
+         * y position of the parent node
+         */
+        parentY: number;
+        /**
+         * x position of the connector relative to the parent node
+         */
+        offsetX?: number;
+        /**
+         * y position of the connector relative to the parent node
+         */
+        offsetY?: number;
+        /**
+         * width of the parent node
+         */
+        parentWidth: number;
+        /**
+         * height of the parent node
+         */
+        parentHeight: number;
+        /**
+         * id of the container where its parent node is
+         */
+        parentContainerId: string;
+    }
+    /**
+     * This component is used to initiate a connection between two nodes. Simply
+     * drag the handle in a node and drop it in another node to create a connection.
+     */
+    export var GraphConnectorHandler: React.FC<IGraphConnectorHandlerProps>;
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export interface IGraphContainerProps {
+    }
+    /**
+     * This component is just a simple container to keep the nodes and lines containers
+     * together
+     * @param props
+     * @returns
+     */
+    export var GraphContainer: React.FC<IGraphContainerProps>;
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        /// <reference types="react" />
+    /**
+     * this context is used to pass callbacks to the graph nodes and connections
+     */
+    export interface IGraphContext {
+        onNodesConnected?: (sourceId: string, targetId: string) => void;
+        onLineSelected?: (lineId: string) => void;
+        onNodeSelected?: (nodeId: string) => void;
+    }
+    export var GraphContextManager: import("react").Context<IGraphContext>;
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        /**
+     * props for the GraphLine component
+     */
+    export interface IGraphLineProps {
+        /**
+         * id of the line. temporary lines can have no id
+         */
+        id?: string;
+        /**
+         * starting x pos of the line
+         */
+        x1: number;
+        /**
+         * ending x pos of the line
+         */
+        x2: number;
+        /**
+         * starting y pos of the line
+         */
+        y1: number;
+        /**
+         * ending y pos of the line
+         */
+        y2: number;
+        /**
+         * is the line selected
+         */
+        selected?: boolean;
+        /**
+         * does the line have a direction
+         */
+        directional?: boolean;
+    }
+    export const MarkerArrowId = "arrow";
+    /**
+     * This component draws a SVG line between two points, with an optional marker
+     * indicating direction
+     */
+    export var GraphLine: React.FC<IGraphLineProps>;
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        /**
+     * props for the GraphLineContainer
+     */
+    export interface IGraphLinesContainerProps {
+        /**
+         * id of the container
+         */
+        id: string;
+    }
+    /**
+     * this component handles the dragging of new connections
+     * @param props
+     * @returns
+     */
+    export var GraphLinesContainer: React.FC<IGraphLinesContainerProps>;
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export interface IGraphNodeProps {
+        id: string;
+        name: string;
+        x: number;
+        y: number;
+        selected?: boolean;
+        width?: number;
+        height?: number;
+        highlighted?: boolean;
+        parentContainerId: string;
+    }
+    export var GraphNode: React.FC<IGraphNodeProps>;
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export interface IGraphContainerProps {
+        onNodeMoved: (id: string, x: number, y: number) => void;
+        id: string;
+    }
+    /**
+     * This component contains all the nodes and handles their dragging
+     */
+    export var GraphNodesContainer: React.FC<IGraphContainerProps>;
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export type IVisualRecordsType = Record<string, {
+        x: number;
+        y: number;
+    }>;
+    export type IConnectionType = {
+        id: string;
+        sourceId: string;
+        targetId: string;
+    };
+    export type ICustomDataType = {
+        type: string;
+        value: any;
+    };
+    export type INodeType = {
+        id: string;
+        label: string;
+        customData?: ICustomDataType;
+    };
+    /**
+     * props for the node renderer
+     */
+    export interface INodeRendererProps {
+        /**
+         * array of connections between nodes
+         */
+        connections: IConnectionType[];
+        /**
+         * function called when a new connection is created
+         */
+        updateConnections: (sourceId: string, targetId: string) => void;
+        /**
+         * function called when a connection is deleted
+         */
+        deleteLine: (lineId: string) => void;
+        /**
+         * function called when a node is deleted
+         */
+        deleteNode: (nodeId: string) => void;
+        /**
+         * array of all nodes
+         */
+        nodes: INodeType[];
+        /**
+         * id of the node to highlight
+         */
+        highlightedNode?: BABYLON.Nullable<string>;
+        /**
+         * function to be called if a node is selected
+         */
+        selectNode?: (nodeId: BABYLON.Nullable<string>) => void;
+        /**
+         * id of this renderer
+         */
+        id: string;
+        /**
+         * optional list of custom components to be rendered inside nodes of
+         * a certain type
+         */
+        customComponents?: Record<string, React.ComponentType<any>>;
+    }
+    /**
+     * This component is a bridge between the app logic related to the graph, and the actual rendering
+     * of it. It manages the nodes' positions and selection states.
+     * @param props
+     * @returns
+     */
+    export const NodeRenderer: (props: INodeRendererProps) => JSX.Element;
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        /**
+     * utility hook to assist using the graph context
+     * @returns
+     */
+    export const useGraphContext: () => IGraphContext;
+
+
+
 }
 declare module BABYLON.NodeEditor {
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "babylonjs-node-editor",
-    "version": "5.32.1",
+    "version": "5.33.0",
     "main": "babylon.nodeEditor.js",
     "types": "babylon.nodeEditor.module.d.ts",
     "files": [
@@ -14,7 +14,7 @@
         "clean": "rimraf dist && rimraf babylon*.*"
     },
     "dependencies": {
-        "babylonjs": "^5.32.1"
+        "babylonjs": "^5.33.0"
     },
     "devDependencies": {
         "@dev/build-tools": "1.0.0",