babylonjs-node-editor 5.26.1 → 5.27.0

package/babylon.nodeEditor.d.ts

@@ -1027,6 +1027,9 @@ declare module BABYLON.NodeEditor.SharedUIComponents {
         onPanButtonClicked?: () => void;
         onZoomButtonClicked?: () => void;
         onFitButtonClicked?: () => void;
+        onArtboardColorChanged?: (newColor: string) => void;
+        artboardColor?: string;
+        artboardColorPickerColor?: string;
     }
     export var CommandBarComponent: React.FC<ICommandBarComponentProps>;
 
@@ -1110,6 +1113,104 @@ declare module BABYLON.NodeEditor.SharedUIComponents {
 
 
 
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export interface IColorComponentEntryProps {
+        value: number;
+        label: string;
+        max?: number;
+        min?: number;
+        onChange: (value: number) => void;
+        disabled?: boolean;
+        lockObject: BABYLON.NodeEditor.SharedUIComponents.LockObject;
+    }
+    export class ColorComponentEntry extends React.Component<IColorComponentEntryProps> {
+        constructor(props: IColorComponentEntryProps);
+        updateValue(valueString: string): void;
+        lock(): void;
+        unlock(): void;
+        render(): JSX.Element;
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        /**
+     * Interface used to specify creation options for color picker
+     */
+    export interface IColorPickerProps {
+        color: BABYLON.Color3 | BABYLON.Color4;
+        linearhint?: boolean;
+        debugMode?: boolean;
+        onColorChanged?: (color: BABYLON.Color3 | BABYLON.Color4) => void;
+        lockObject: BABYLON.NodeEditor.SharedUIComponents.LockObject;
+        backgroundColor?: string;
+    }
+    /**
+     * Interface used to specify creation options for color picker
+     */
+    export interface IColorPickerState {
+        color: BABYLON.Color3;
+        alpha: number;
+    }
+    /**
+     * Class used to create a color picker
+     */
+    export class ColorPicker extends React.Component<IColorPickerProps, IColorPickerState> {
+        private _saturationRef;
+        private _hueRef;
+        private _isSaturationPointerDown;
+        private _isHuePointerDown;
+        constructor(props: IColorPickerProps);
+        shouldComponentUpdate(nextProps: IColorPickerProps, nextState: IColorPickerState): boolean;
+        onSaturationPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
+        onSaturationPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
+        onSaturationPointerMove(evt: React.PointerEvent<HTMLDivElement>): void;
+        onHuePointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
+        onHuePointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
+        onHuePointerMove(evt: React.PointerEvent<HTMLDivElement>): void;
+        private _evaluateSaturation;
+        private _evaluateHue;
+        componentDidUpdate(): void;
+        raiseOnColorChanged(): void;
+        render(): JSX.Element;
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export interface IHexColorProps {
+        value: string;
+        expectedLength: number;
+        onChange: (value: string) => void;
+        lockObject: BABYLON.NodeEditor.SharedUIComponents.LockObject;
+    }
+    export class HexColor extends React.Component<IHexColorProps, {
+        hex: string;
+    }> {
+        constructor(props: IHexColorProps);
+        shouldComponentUpdate(nextProps: IHexColorProps, nextState: {
+            hex: string;
+        }): boolean;
+        lock(): void;
+        unlock(): void;
+        updateHexValue(valueString: string): void;
+        render(): JSX.Element;
+    }
+
+
+
 }
 declare module BABYLON.NodeEditor {
 
@@ -1138,6 +1239,85 @@ declare module BABYLON.NodeEditor.SharedUIComponents {
 
 
 
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export interface IColorLineComponentProps {
+        label: string;
+        target: any;
+        propertyName: string;
+        onPropertyChangedObservable: BABYLON.Observable<BABYLON.NodeEditor.SharedUIComponents.PropertyChangedEvent>;
+        onChange?: () => void;
+        isLinear?: boolean;
+        icon?: string;
+        iconLabel?: string;
+        disableAlpha?: boolean;
+        lockObject: BABYLON.NodeEditor.SharedUIComponents.LockObject;
+    }
+    interface IColorLineComponentState {
+        isExpanded: boolean;
+        color: BABYLON.Color4;
+    }
+    export class ColorLineComponent extends React.Component<IColorLineComponentProps, IColorLineComponentState> {
+        constructor(props: IColorLineComponentProps);
+        shouldComponentUpdate(nextProps: IColorLineComponentProps, nextState: IColorLineComponentState): boolean;
+        getValue(props?: Readonly<IColorLineComponentProps> & Readonly<{
+            children?: React.ReactNode;
+        }>): BABYLON.Color4;
+        setColorFromString(colorString: string): void;
+        setColor(newColor: BABYLON.Color4): void;
+        switchExpandState(): void;
+        updateStateR(value: number): void;
+        updateStateG(value: number): void;
+        updateStateB(value: number): void;
+        updateStateA(value: number): void;
+        copyToClipboard(): void;
+        private _convertToColor;
+        private _toColor3;
+        render(): JSX.Element;
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export interface IColorPickerComponentProps {
+        value: BABYLON.Color4 | BABYLON.Color3;
+        linearHint?: boolean;
+        onColorChanged: (newOne: string) => void;
+        icon?: string;
+        iconLabel?: string;
+        shouldPopRight?: boolean;
+        lockObject?: BABYLON.NodeEditor.SharedUIComponents.LockObject;
+        backgroundColor?: string;
+    }
+    interface IColorPickerComponentState {
+        pickerEnabled: boolean;
+        color: BABYLON.Color3 | BABYLON.Color4;
+        hex: string;
+    }
+    export class ColorPickerLineComponent extends React.Component<IColorPickerComponentProps, IColorPickerComponentState> {
+        private _floatRef;
+        private _floatHostRef;
+        private _coverRef;
+        constructor(props: IColorPickerComponentProps);
+        syncPositions(): void;
+        shouldComponentUpdate(nextProps: IColorPickerComponentProps, nextState: IColorPickerComponentState): boolean;
+        getHexString(props?: Readonly<IColorPickerComponentProps> & Readonly<{
+            children?: React.ReactNode;
+        }>): string;
+        componentDidUpdate(): void;
+        componentDidMount(): void;
+        render(): JSX.Element;
+    }
+
+
+
 }
 declare module BABYLON.NodeEditor {
 
@@ -1161,6 +1341,42 @@ declare module BABYLON.NodeEditor.SharedUIComponents {
 
 
 
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        interface INumericInputComponentProps {
+        label: string;
+        value: number;
+        step?: number;
+        onChange: (value: number) => void;
+        precision?: number;
+        icon?: string;
+        iconLabel?: string;
+        lockObject: BABYLON.NodeEditor.SharedUIComponents.LockObject;
+    }
+    export class NumericInputComponent extends React.Component<INumericInputComponentProps, {
+        value: string;
+    }> {
+        static defaultProps: {
+            step: number;
+        };
+        private _localChange;
+        constructor(props: INumericInputComponentProps);
+        componentWillUnmount(): void;
+        shouldComponentUpdate(nextProps: INumericInputComponentProps, nextState: {
+            value: string;
+        }): boolean;
+        updateValue(valueString: string): void;
+        onBlur(): void;
+        incrementValue(amount: number): void;
+        onKeyDown(evt: React.KeyboardEvent<HTMLInputElement>): void;
+        render(): JSX.Element;
+    }
+
+
+
 }
 declare module BABYLON.NodeEditor {
 

package/babylon.nodeEditor.module.d.ts

@@ -1371,7 +1371,7 @@ export class HexColor extends React.Component<IHexColorProps, {
 
 }
 declare module "babylonjs-node-editor/components/bars/CommandBarComponent" {
-import * as React from "react";
+import { FC } from "react";
 export interface ICommandBarComponentProps {
     onSaveButtonClicked?: () => void;
     onSaveToSnippetButtonClicked?: () => void;
@@ -1382,8 +1382,11 @@ export interface ICommandBarComponentProps {
     onPanButtonClicked?: () => void;
     onZoomButtonClicked?: () => void;
     onFitButtonClicked?: () => void;
+    onArtboardColorChanged?: (newColor: string) => void;
+    artboardColor?: string;
+    artboardColorPickerColor?: string;
 }
-export const CommandBarComponent: React.FC<ICommandBarComponentProps>;
+export const CommandBarComponent: FC<ICommandBarComponentProps>;
 
 }
 declare module "babylonjs-node-editor/components/bars/CommandButtonComponent" {
@@ -1446,6 +1449,96 @@ declare module "babylonjs-node-editor/components/classNames" {
 export function ClassNames(names: any, styleObject: any): string;
 export function JoinClassNames(styleObject: any, ...names: string[]): string;
 
+}
+declare module "babylonjs-node-editor/components/colorPicker/ColorComponentEntry" {
+import * as React from "react";
+import { LockObject } from "babylonjs-node-editor/tabs/propertyGrids/lockObject";
+export interface IColorComponentEntryProps {
+    value: number;
+    label: string;
+    max?: number;
+    min?: number;
+    onChange: (value: number) => void;
+    disabled?: boolean;
+    lockObject: LockObject;
+}
+export class ColorComponentEntry extends React.Component<IColorComponentEntryProps> {
+    constructor(props: IColorComponentEntryProps);
+    updateValue(valueString: string): void;
+    lock(): void;
+    unlock(): void;
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/components/colorPicker/ColorPicker" {
+import * as React from "react";
+import { Color3, Color4 } from "babylonjs/Maths/math.color";
+import { LockObject } from "babylonjs-node-editor/tabs/propertyGrids/lockObject";
+/**
+ * Interface used to specify creation options for color picker
+ */
+export interface IColorPickerProps {
+    color: Color3 | Color4;
+    linearhint?: boolean;
+    debugMode?: boolean;
+    onColorChanged?: (color: Color3 | Color4) => void;
+    lockObject: LockObject;
+    backgroundColor?: string;
+}
+/**
+ * Interface used to specify creation options for color picker
+ */
+export interface IColorPickerState {
+    color: Color3;
+    alpha: number;
+}
+/**
+ * Class used to create a color picker
+ */
+export class ColorPicker extends React.Component<IColorPickerProps, IColorPickerState> {
+    private _saturationRef;
+    private _hueRef;
+    private _isSaturationPointerDown;
+    private _isHuePointerDown;
+    constructor(props: IColorPickerProps);
+    shouldComponentUpdate(nextProps: IColorPickerProps, nextState: IColorPickerState): boolean;
+    onSaturationPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
+    onSaturationPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
+    onSaturationPointerMove(evt: React.PointerEvent<HTMLDivElement>): void;
+    onHuePointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
+    onHuePointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
+    onHuePointerMove(evt: React.PointerEvent<HTMLDivElement>): void;
+    private _evaluateSaturation;
+    private _evaluateHue;
+    componentDidUpdate(): void;
+    raiseOnColorChanged(): void;
+    render(): JSX.Element;
+}
+
+}
+declare module "babylonjs-node-editor/components/colorPicker/HexColor" {
+import * as React from "react";
+import { LockObject } from "babylonjs-node-editor/tabs/propertyGrids/lockObject";
+export interface IHexColorProps {
+    value: string;
+    expectedLength: number;
+    onChange: (value: string) => void;
+    lockObject: LockObject;
+}
+export class HexColor extends React.Component<IHexColorProps, {
+    hex: string;
+}> {
+    constructor(props: IHexColorProps);
+    shouldComponentUpdate(nextProps: IHexColorProps, nextState: {
+        hex: string;
+    }): boolean;
+    lock(): void;
+    unlock(): void;
+    updateHexValue(valueString: string): void;
+    render(): JSX.Element;
+}
+
 }
 declare module "babylonjs-node-editor/components/Icon" {
 /// <reference types="react" />
@@ -1465,6 +1558,85 @@ export type LabelProps = {
 };
 export const Label: React.FC<LabelProps>;
 
+}
+declare module "babylonjs-node-editor/components/lines/ColorLineComponent" {
+import * as React from "react";
+import { Observable } from "babylonjs/Misc/observable";
+import { Color4 } from "babylonjs/Maths/math.color";
+import { PropertyChangedEvent } from "babylonjs-node-editor/propertyChangedEvent";
+import { LockObject } from "babylonjs-node-editor/tabs/propertyGrids/lockObject";
+export interface IColorLineComponentProps {
+    label: string;
+    target: any;
+    propertyName: string;
+    onPropertyChangedObservable: Observable<PropertyChangedEvent>;
+    onChange?: () => void;
+    isLinear?: boolean;
+    icon?: string;
+    iconLabel?: string;
+    disableAlpha?: boolean;
+    lockObject: LockObject;
+}
+interface IColorLineComponentState {
+    isExpanded: boolean;
+    color: Color4;
+}
+export class ColorLineComponent extends React.Component<IColorLineComponentProps, IColorLineComponentState> {
+    constructor(props: IColorLineComponentProps);
+    shouldComponentUpdate(nextProps: IColorLineComponentProps, nextState: IColorLineComponentState): boolean;
+    getValue(props?: Readonly<IColorLineComponentProps> & Readonly<{
+        children?: React.ReactNode;
+    }>): Color4;
+    setColorFromString(colorString: string): void;
+    setColor(newColor: Color4): void;
+    switchExpandState(): void;
+    updateStateR(value: number): void;
+    updateStateG(value: number): void;
+    updateStateB(value: number): void;
+    updateStateA(value: number): void;
+    copyToClipboard(): void;
+    private _convertToColor;
+    private _toColor3;
+    render(): JSX.Element;
+}
+export {};
+
+}
+declare module "babylonjs-node-editor/components/lines/ColorPickerLineComponent" {
+import * as React from "react";
+import { Color4, Color3 } from "babylonjs/Maths/math.color";
+import { LockObject } from "babylonjs-node-editor/tabs/propertyGrids/lockObject";
+export interface IColorPickerComponentProps {
+    value: Color4 | Color3;
+    linearHint?: boolean;
+    onColorChanged: (newOne: string) => void;
+    icon?: string;
+    iconLabel?: string;
+    shouldPopRight?: boolean;
+    lockObject?: LockObject;
+    backgroundColor?: string;
+}
+interface IColorPickerComponentState {
+    pickerEnabled: boolean;
+    color: Color3 | Color4;
+    hex: string;
+}
+export class ColorPickerLineComponent extends React.Component<IColorPickerComponentProps, IColorPickerComponentState> {
+    private _floatRef;
+    private _floatHostRef;
+    private _coverRef;
+    constructor(props: IColorPickerComponentProps);
+    syncPositions(): void;
+    shouldComponentUpdate(nextProps: IColorPickerComponentProps, nextState: IColorPickerComponentState): boolean;
+    getHexString(props?: Readonly<IColorPickerComponentProps> & Readonly<{
+        children?: React.ReactNode;
+    }>): string;
+    componentDidUpdate(): void;
+    componentDidMount(): void;
+    render(): JSX.Element;
+}
+export {};
+
 }
 declare module "babylonjs-node-editor/components/lines/FileButtonLineComponent" {
 import * as React from "react";
@@ -1484,6 +1656,40 @@ export class FileButtonLineComponent extends React.Component<IFileButtonLineComp
     render(): JSX.Element;
 }
 
+}
+declare module "babylonjs-node-editor/components/lines/NumericInputComponent" {
+import * as React from "react";
+import { LockObject } from "babylonjs-node-editor/tabs/propertyGrids/lockObject";
+interface INumericInputComponentProps {
+    label: string;
+    value: number;
+    step?: number;
+    onChange: (value: number) => void;
+    precision?: number;
+    icon?: string;
+    iconLabel?: string;
+    lockObject: LockObject;
+}
+export class NumericInputComponent extends React.Component<INumericInputComponentProps, {
+    value: string;
+}> {
+    static defaultProps: {
+        step: number;
+    };
+    private _localChange;
+    constructor(props: INumericInputComponentProps);
+    componentWillUnmount(): void;
+    shouldComponentUpdate(nextProps: INumericInputComponentProps, nextState: {
+        value: string;
+    }): boolean;
+    updateValue(valueString: string): void;
+    onBlur(): void;
+    incrementValue(amount: number): void;
+    onKeyDown(evt: React.KeyboardEvent<HTMLInputElement>): void;
+    render(): JSX.Element;
+}
+export {};
+
 }
 declare module "babylonjs-node-editor/components/MessageDialog" {
 import * as React from "react";
@@ -4442,6 +4648,9 @@ declare module BABYLON.NodeEditor.SharedUIComponents {
         onPanButtonClicked?: () => void;
         onZoomButtonClicked?: () => void;
         onFitButtonClicked?: () => void;
+        onArtboardColorChanged?: (newColor: string) => void;
+        artboardColor?: string;
+        artboardColorPickerColor?: string;
     }
     export var CommandBarComponent: React.FC<ICommandBarComponentProps>;
 
@@ -4525,6 +4734,104 @@ declare module BABYLON.NodeEditor.SharedUIComponents {
 
 
 
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export interface IColorComponentEntryProps {
+        value: number;
+        label: string;
+        max?: number;
+        min?: number;
+        onChange: (value: number) => void;
+        disabled?: boolean;
+        lockObject: BABYLON.NodeEditor.SharedUIComponents.LockObject;
+    }
+    export class ColorComponentEntry extends React.Component<IColorComponentEntryProps> {
+        constructor(props: IColorComponentEntryProps);
+        updateValue(valueString: string): void;
+        lock(): void;
+        unlock(): void;
+        render(): JSX.Element;
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        /**
+     * Interface used to specify creation options for color picker
+     */
+    export interface IColorPickerProps {
+        color: BABYLON.Color3 | BABYLON.Color4;
+        linearhint?: boolean;
+        debugMode?: boolean;
+        onColorChanged?: (color: BABYLON.Color3 | BABYLON.Color4) => void;
+        lockObject: BABYLON.NodeEditor.SharedUIComponents.LockObject;
+        backgroundColor?: string;
+    }
+    /**
+     * Interface used to specify creation options for color picker
+     */
+    export interface IColorPickerState {
+        color: BABYLON.Color3;
+        alpha: number;
+    }
+    /**
+     * Class used to create a color picker
+     */
+    export class ColorPicker extends React.Component<IColorPickerProps, IColorPickerState> {
+        private _saturationRef;
+        private _hueRef;
+        private _isSaturationPointerDown;
+        private _isHuePointerDown;
+        constructor(props: IColorPickerProps);
+        shouldComponentUpdate(nextProps: IColorPickerProps, nextState: IColorPickerState): boolean;
+        onSaturationPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
+        onSaturationPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
+        onSaturationPointerMove(evt: React.PointerEvent<HTMLDivElement>): void;
+        onHuePointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
+        onHuePointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
+        onHuePointerMove(evt: React.PointerEvent<HTMLDivElement>): void;
+        private _evaluateSaturation;
+        private _evaluateHue;
+        componentDidUpdate(): void;
+        raiseOnColorChanged(): void;
+        render(): JSX.Element;
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export interface IHexColorProps {
+        value: string;
+        expectedLength: number;
+        onChange: (value: string) => void;
+        lockObject: BABYLON.NodeEditor.SharedUIComponents.LockObject;
+    }
+    export class HexColor extends React.Component<IHexColorProps, {
+        hex: string;
+    }> {
+        constructor(props: IHexColorProps);
+        shouldComponentUpdate(nextProps: IHexColorProps, nextState: {
+            hex: string;
+        }): boolean;
+        lock(): void;
+        unlock(): void;
+        updateHexValue(valueString: string): void;
+        render(): JSX.Element;
+    }
+
+
+
 }
 declare module BABYLON.NodeEditor {
 
@@ -4553,6 +4860,85 @@ declare module BABYLON.NodeEditor.SharedUIComponents {
 
 
 
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export interface IColorLineComponentProps {
+        label: string;
+        target: any;
+        propertyName: string;
+        onPropertyChangedObservable: BABYLON.Observable<BABYLON.NodeEditor.SharedUIComponents.PropertyChangedEvent>;
+        onChange?: () => void;
+        isLinear?: boolean;
+        icon?: string;
+        iconLabel?: string;
+        disableAlpha?: boolean;
+        lockObject: BABYLON.NodeEditor.SharedUIComponents.LockObject;
+    }
+    interface IColorLineComponentState {
+        isExpanded: boolean;
+        color: BABYLON.Color4;
+    }
+    export class ColorLineComponent extends React.Component<IColorLineComponentProps, IColorLineComponentState> {
+        constructor(props: IColorLineComponentProps);
+        shouldComponentUpdate(nextProps: IColorLineComponentProps, nextState: IColorLineComponentState): boolean;
+        getValue(props?: Readonly<IColorLineComponentProps> & Readonly<{
+            children?: React.ReactNode;
+        }>): BABYLON.Color4;
+        setColorFromString(colorString: string): void;
+        setColor(newColor: BABYLON.Color4): void;
+        switchExpandState(): void;
+        updateStateR(value: number): void;
+        updateStateG(value: number): void;
+        updateStateB(value: number): void;
+        updateStateA(value: number): void;
+        copyToClipboard(): void;
+        private _convertToColor;
+        private _toColor3;
+        render(): JSX.Element;
+    }
+
+
+
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        export interface IColorPickerComponentProps {
+        value: BABYLON.Color4 | BABYLON.Color3;
+        linearHint?: boolean;
+        onColorChanged: (newOne: string) => void;
+        icon?: string;
+        iconLabel?: string;
+        shouldPopRight?: boolean;
+        lockObject?: BABYLON.NodeEditor.SharedUIComponents.LockObject;
+        backgroundColor?: string;
+    }
+    interface IColorPickerComponentState {
+        pickerEnabled: boolean;
+        color: BABYLON.Color3 | BABYLON.Color4;
+        hex: string;
+    }
+    export class ColorPickerLineComponent extends React.Component<IColorPickerComponentProps, IColorPickerComponentState> {
+        private _floatRef;
+        private _floatHostRef;
+        private _coverRef;
+        constructor(props: IColorPickerComponentProps);
+        syncPositions(): void;
+        shouldComponentUpdate(nextProps: IColorPickerComponentProps, nextState: IColorPickerComponentState): boolean;
+        getHexString(props?: Readonly<IColorPickerComponentProps> & Readonly<{
+            children?: React.ReactNode;
+        }>): string;
+        componentDidUpdate(): void;
+        componentDidMount(): void;
+        render(): JSX.Element;
+    }
+
+
+
 }
 declare module BABYLON.NodeEditor {
 
@@ -4576,6 +4962,42 @@ declare module BABYLON.NodeEditor.SharedUIComponents {
 
 
 
+}
+declare module BABYLON.NodeEditor {
+
+}
+declare module BABYLON.NodeEditor.SharedUIComponents {
+        interface INumericInputComponentProps {
+        label: string;
+        value: number;
+        step?: number;
+        onChange: (value: number) => void;
+        precision?: number;
+        icon?: string;
+        iconLabel?: string;
+        lockObject: BABYLON.NodeEditor.SharedUIComponents.LockObject;
+    }
+    export class NumericInputComponent extends React.Component<INumericInputComponentProps, {
+        value: string;
+    }> {
+        static defaultProps: {
+            step: number;
+        };
+        private _localChange;
+        constructor(props: INumericInputComponentProps);
+        componentWillUnmount(): void;
+        shouldComponentUpdate(nextProps: INumericInputComponentProps, nextState: {
+            value: string;
+        }): boolean;
+        updateValue(valueString: string): void;
+        onBlur(): void;
+        incrementValue(amount: number): void;
+        onKeyDown(evt: React.KeyboardEvent<HTMLInputElement>): void;
+        render(): JSX.Element;
+    }
+
+
+
 }
 declare module BABYLON.NodeEditor {
 

package/package.json

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