@babylonjs/gui-editor 5.12.1 → 5.13.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1510,6 +1510,7 @@ export interface IButtonLineComponentProps {
1510
1510
  onClick: () => void;
1511
1511
  icon?: string;
1512
1512
  iconLabel?: string;
1513
+ isDisabled?: boolean;
1513
1514
  }
1514
1515
  export class ButtonLineComponent extends React.Component<IButtonLineComponentProps> {
1515
1516
  constructor(props: IButtonLineComponentProps);
@@ -1570,7 +1571,7 @@ export interface IColor3LineComponentProps {
1570
1571
  icon?: string;
1571
1572
  lockObject?: LockObject;
1572
1573
  iconLabel?: string;
1573
- onValueChange?: (value: string) => void;
1574
+ onChange?: () => void;
1574
1575
  }
1575
1576
  export class Color3LineComponent extends React.Component<IColor3LineComponentProps> {
1576
1577
  render(): JSX.Element;
@@ -1929,6 +1930,43 @@ export class LinkButtonComponent extends React.Component<ILinkButtonComponentPro
1929
1930
  }
1930
1931
  export {};
1931
1932
 
1933
+ }
1934
+ declare module "@babylonjs/gui-editor/lines/matrixLineComponent" {
1935
+ import * as React from "react";
1936
+ import { Vector3, Vector4 } from "@babylonjs/core/Maths/math.vector";
1937
+ import { Matrix } from "@babylonjs/core/Maths/math.vector";
1938
+ import { Observable } from "@babylonjs/core/Misc/observable";
1939
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
1940
+ interface IMatrixLineComponentProps {
1941
+ label: string;
1942
+ target: any;
1943
+ propertyName: string;
1944
+ step?: number;
1945
+ onChange?: (newValue: Matrix) => void;
1946
+ onModeChange?: (mode: number) => void;
1947
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1948
+ mode?: number;
1949
+ }
1950
+ export class MatrixLineComponent extends React.Component<IMatrixLineComponentProps, {
1951
+ value: Matrix;
1952
+ mode: number;
1953
+ angle: number;
1954
+ }> {
1955
+ private _localChange;
1956
+ constructor(props: IMatrixLineComponentProps);
1957
+ shouldComponentUpdate(nextProps: IMatrixLineComponentProps, nextState: {
1958
+ value: Matrix;
1959
+ mode: number;
1960
+ angle: number;
1961
+ }): boolean;
1962
+ raiseOnPropertyChanged(previousValue: Vector3): void;
1963
+ updateMatrix(): void;
1964
+ updateRow(value: Vector4, row: number): void;
1965
+ updateBasedOnMode(value: number): void;
1966
+ render(): JSX.Element;
1967
+ }
1968
+ export {};
1969
+
1932
1970
  }
1933
1971
  declare module "@babylonjs/gui-editor/lines/messageLineComponent" {
1934
1972
  import * as React from "react";
@@ -1986,24 +2024,29 @@ export interface IOptionsLineComponentProps {
1986
2024
  propertyName: string;
1987
2025
  options: IInspectableOptions[];
1988
2026
  noDirectUpdate?: boolean;
1989
- onSelect?: (value: number) => void;
1990
- extractValue?: () => number;
2027
+ onSelect?: (value: number | string) => void;
2028
+ extractValue?: (target: any) => number | string;
1991
2029
  onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1992
2030
  allowNullValue?: boolean;
1993
2031
  icon?: string;
1994
2032
  iconLabel?: string;
2033
+ className?: string;
2034
+ valuesAreStrings?: boolean;
2035
+ defaultIfNull?: number;
1995
2036
  }
1996
2037
  export class OptionsLineComponent extends React.Component<IOptionsLineComponentProps, {
1997
- value: number;
2038
+ value: number | string;
1998
2039
  }> {
1999
2040
  private _localChange;
2000
2041
  private _remapValueIn;
2001
2042
  private _remapValueOut;
2043
+ private _getValue;
2002
2044
  constructor(props: IOptionsLineComponentProps);
2003
2045
  shouldComponentUpdate(nextProps: IOptionsLineComponentProps, nextState: {
2004
2046
  value: number;
2005
2047
  }): boolean;
2006
2048
  raiseOnPropertyChanged(newValue: number, previousValue: number): void;
2049
+ setValue(value: string | number): void;
2007
2050
  updateValue(valueString: string): void;
2008
2051
  render(): JSX.Element;
2009
2052
  }
@@ -2121,6 +2164,8 @@ export interface ITextInputLineComponentProps {
2121
2164
  max?: number;
2122
2165
  placeholder?: string;
2123
2166
  unit?: React.ReactNode;
2167
+ validator?: (value: string) => boolean;
2168
+ multilines?: boolean;
2124
2169
  }
2125
2170
  export class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
2126
2171
  value: string;
@@ -2281,14 +2326,15 @@ import { Observable } from "@babylonjs/core/Misc/observable";
2281
2326
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/propertyChangedEvent";
2282
2327
  interface IVector4LineComponentProps {
2283
2328
  label: string;
2284
- target: any;
2285
- propertyName: string;
2329
+ target?: any;
2330
+ propertyName?: string;
2286
2331
  step?: number;
2287
2332
  onChange?: (newvalue: Vector4) => void;
2288
2333
  useEuler?: boolean;
2289
2334
  onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2290
2335
  icon?: string;
2291
2336
  iconLabel?: string;
2337
+ value?: Vector4;
2292
2338
  }
2293
2339
  export class Vector4LineComponent extends React.Component<IVector4LineComponentProps, {
2294
2340
  isExpanded: boolean;
@@ -2315,6 +2361,660 @@ export class Vector4LineComponent extends React.Component<IVector4LineComponentP
2315
2361
  }
2316
2362
  export {};
2317
2363
 
2364
+ }
2365
+ declare module "@babylonjs/gui-editor/nodeGraphSystem/displayLedger" {
2366
+ export class DisplayLedger {
2367
+ static RegisteredControls: {
2368
+ [key: string]: any;
2369
+ };
2370
+ }
2371
+
2372
+ }
2373
+ declare module "@babylonjs/gui-editor/nodeGraphSystem/frameNodePort" {
2374
+ import { IDisplayManager } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/displayManager";
2375
+ import { Observable } from "@babylonjs/core/Misc/observable";
2376
+ import { Nullable } from "@babylonjs/core/types";
2377
+ import { IPortData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/portData";
2378
+ import { NodePort } from "@babylonjs/gui-editor/nodeGraphSystem/nodePort";
2379
+ import { GraphNode } from "@babylonjs/gui-editor/nodeGraphSystem/graphNode";
2380
+ import { FramePortPosition } from "@babylonjs/gui-editor/nodeGraphSystem/graphFrame";
2381
+ import { StateManager } from "@babylonjs/gui-editor/nodeGraphSystem/stateManager";
2382
+ export class FrameNodePort extends NodePort {
2383
+ portData: IPortData;
2384
+ node: GraphNode;
2385
+ private _parentFrameId;
2386
+ private _isInput;
2387
+ private _framePortPosition;
2388
+ private _framePortId;
2389
+ private _onFramePortPositionChangedObservable;
2390
+ get parentFrameId(): number;
2391
+ get onFramePortPositionChangedObservable(): Observable<FrameNodePort>;
2392
+ get isInput(): boolean;
2393
+ get framePortId(): number;
2394
+ get framePortPosition(): FramePortPosition;
2395
+ set framePortPosition(position: FramePortPosition);
2396
+ constructor(portContainer: HTMLElement, portData: IPortData, node: GraphNode, stateManager: StateManager, isInput: boolean, framePortId: number, parentFrameId: number);
2397
+ static CreateFrameNodePortElement(portData: IPortData, node: GraphNode, root: HTMLElement, displayManager: Nullable<IDisplayManager>, stateManager: StateManager, isInput: boolean, framePortId: number, parentFrameId: number): FrameNodePort;
2398
+ }
2399
+
2400
+ }
2401
+ declare module "@babylonjs/gui-editor/nodeGraphSystem/graphCanvas" {
2402
+ import * as React from "react";
2403
+ import { GraphNode } from "@babylonjs/gui-editor/nodeGraphSystem/graphNode";
2404
+ import { Nullable } from "@babylonjs/core/types";
2405
+ import { NodeLink } from "@babylonjs/gui-editor/nodeGraphSystem/nodeLink";
2406
+ import { NodePort } from "@babylonjs/gui-editor/nodeGraphSystem/nodePort";
2407
+ import { GraphFrame } from "@babylonjs/gui-editor/nodeGraphSystem/graphFrame";
2408
+ import { IEditorData, IFrameData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeLocationInfo";
2409
+ import { StateManager } from "@babylonjs/gui-editor/nodeGraphSystem/stateManager";
2410
+ import { INodeData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeData";
2411
+ import { IPortData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/portData";
2412
+ import { INodeContainer } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeContainer";
2413
+ import "@babylonjs/gui-editor/nodeGraphSystem/scss/graphCanvas.scss";
2414
+ export interface IGraphCanvasComponentProps {
2415
+ stateManager: StateManager;
2416
+ onEmitNewNode: (nodeData: INodeData) => GraphNode;
2417
+ }
2418
+ export class GraphCanvasComponent extends React.Component<IGraphCanvasComponentProps> implements INodeContainer {
2419
+ private readonly _minZoom;
2420
+ private readonly _maxZoom;
2421
+ private _hostCanvas;
2422
+ private _graphCanvas;
2423
+ private _selectionContainer;
2424
+ private _frameContainer;
2425
+ private _svgCanvas;
2426
+ private _rootContainer;
2427
+ private _nodes;
2428
+ private _links;
2429
+ private _mouseStartPointX;
2430
+ private _mouseStartPointY;
2431
+ private _dropPointX;
2432
+ private _dropPointY;
2433
+ private _selectionStartX;
2434
+ private _selectionStartY;
2435
+ private _candidateLinkedHasMoved;
2436
+ private _x;
2437
+ private _y;
2438
+ private _zoom;
2439
+ private _selectedNodes;
2440
+ private _selectedLink;
2441
+ private _selectedPort;
2442
+ private _candidateLink;
2443
+ private _candidatePort;
2444
+ private _gridSize;
2445
+ private _selectionBox;
2446
+ private _selectedFrames;
2447
+ private _frameCandidate;
2448
+ private _frames;
2449
+ private _nodeDataContentList;
2450
+ private _altKeyIsPressed;
2451
+ private _multiKeyIsPressed;
2452
+ private _oldY;
2453
+ _frameIsMoving: boolean;
2454
+ _isLoading: boolean;
2455
+ get gridSize(): number;
2456
+ set gridSize(value: number);
2457
+ get stateManager(): StateManager;
2458
+ get nodes(): GraphNode[];
2459
+ get links(): NodeLink[];
2460
+ get frames(): GraphFrame[];
2461
+ get zoom(): number;
2462
+ set zoom(value: number);
2463
+ get x(): number;
2464
+ set x(value: number);
2465
+ get y(): number;
2466
+ set y(value: number);
2467
+ get selectedNodes(): GraphNode[];
2468
+ get selectedLink(): Nullable<NodeLink>;
2469
+ get selectedFrames(): GraphFrame[];
2470
+ get selectedPort(): Nullable<NodePort>;
2471
+ get canvasContainer(): HTMLDivElement;
2472
+ get hostCanvas(): HTMLDivElement;
2473
+ get svgCanvas(): HTMLElement;
2474
+ get selectionContainer(): HTMLDivElement;
2475
+ get frameContainer(): HTMLDivElement;
2476
+ private _selectedFrameAndNodesConflict;
2477
+ constructor(props: IGraphCanvasComponentProps);
2478
+ getCachedData(): any[];
2479
+ removeDataFromCache(data: any): void;
2480
+ createNodeFromObject(nodeData: INodeData, onNodeCreated: (data: any) => void, recursion?: boolean): GraphNode;
2481
+ getGridPosition(position: number, useCeil?: boolean): number;
2482
+ getGridPositionCeil(position: number): number;
2483
+ updateTransform(): void;
2484
+ onKeyUp(): void;
2485
+ findNodeFromData(data: any): GraphNode;
2486
+ reset(): void;
2487
+ connectPorts(pointA: IPortData, pointB: IPortData): void;
2488
+ removeLink(link: NodeLink): void;
2489
+ appendNode(nodeData: INodeData): GraphNode;
2490
+ distributeGraph(): void;
2491
+ componentDidMount(): void;
2492
+ onMove(evt: React.PointerEvent): void;
2493
+ onDown(evt: React.PointerEvent<HTMLElement>): void;
2494
+ onUp(evt: React.PointerEvent): void;
2495
+ onWheel(evt: React.WheelEvent): void;
2496
+ zoomToFit(): void;
2497
+ processCandidatePort(): void;
2498
+ connectNodes(nodeA: GraphNode, pointA: IPortData, nodeB: GraphNode, pointB: IPortData): void;
2499
+ processEditorData(editorData: IEditorData): void;
2500
+ reOrganize(editorData?: Nullable<IEditorData>, isImportingAFrame?: boolean): void;
2501
+ addFrame(frameData: IFrameData): void;
2502
+ render(): JSX.Element;
2503
+ }
2504
+
2505
+ }
2506
+ declare module "@babylonjs/gui-editor/nodeGraphSystem/graphFrame" {
2507
+ import { GraphNode } from "@babylonjs/gui-editor/nodeGraphSystem/graphNode";
2508
+ import { GraphCanvasComponent } from "@babylonjs/gui-editor/nodeGraphSystem/graphCanvas";
2509
+ import { Nullable } from "@babylonjs/core/types";
2510
+ import { Observable } from "@babylonjs/core/Misc/observable";
2511
+ import { Color3 } from "@babylonjs/core/Maths/math.color";
2512
+ import { FrameNodePort } from "@babylonjs/gui-editor/nodeGraphSystem/frameNodePort";
2513
+ import { IFrameData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeLocationInfo";
2514
+ export enum FramePortPosition {
2515
+ Top = 0,
2516
+ Middle = 1,
2517
+ Bottom = 2
2518
+ }
2519
+ export class GraphFrame {
2520
+ private readonly _collapsedWidth;
2521
+ private static _FrameCounter;
2522
+ private static _FramePortCounter;
2523
+ private _name;
2524
+ private _color;
2525
+ private _x;
2526
+ private _y;
2527
+ private _gridAlignedX;
2528
+ private _gridAlignedY;
2529
+ private _width;
2530
+ private _height;
2531
+ element: HTMLDivElement;
2532
+ private _borderElement;
2533
+ private _headerElement;
2534
+ private _headerTextElement;
2535
+ private _headerCollapseElement;
2536
+ private _headerCloseElement;
2537
+ private _commentsElement;
2538
+ private _portContainer;
2539
+ private _outputPortContainer;
2540
+ private _inputPortContainer;
2541
+ private _nodes;
2542
+ private _ownerCanvas;
2543
+ private _mouseStartPointX;
2544
+ private _mouseStartPointY;
2545
+ private _onSelectionChangedObserver;
2546
+ private _onGraphNodeRemovalObserver;
2547
+ private _onExposePortOnFrameObserver;
2548
+ private _onNodeLinkDisposedObservers;
2549
+ private _isCollapsed;
2550
+ private _frameInPorts;
2551
+ private _frameOutPorts;
2552
+ private _controlledPorts;
2553
+ private _exposedInPorts;
2554
+ private _exposedOutPorts;
2555
+ private _id;
2556
+ private _comments;
2557
+ private _frameIsResizing;
2558
+ private _resizingDirection;
2559
+ private _minFrameHeight;
2560
+ private _minFrameWidth;
2561
+ private _mouseXLimit;
2562
+ onExpandStateChanged: Observable<GraphFrame>;
2563
+ private readonly _closeSVG;
2564
+ private readonly _expandSVG;
2565
+ private readonly _collapseSVG;
2566
+ get id(): number;
2567
+ get isCollapsed(): boolean;
2568
+ private _createInputPort;
2569
+ private _markFramePortPositions;
2570
+ private _createFramePorts;
2571
+ private _removePortFromExposedWithNode;
2572
+ private _removePortFromExposedWithLink;
2573
+ private _createInputPorts;
2574
+ private _createOutputPorts;
2575
+ redrawFramePorts(): void;
2576
+ set isCollapsed(value: boolean);
2577
+ get nodes(): GraphNode[];
2578
+ get ports(): FrameNodePort[];
2579
+ get name(): string;
2580
+ set name(value: string);
2581
+ get color(): Color3;
2582
+ set color(value: Color3);
2583
+ get x(): number;
2584
+ set x(value: number);
2585
+ get y(): number;
2586
+ set y(value: number);
2587
+ get width(): number;
2588
+ set width(value: number);
2589
+ get height(): number;
2590
+ set height(value: number);
2591
+ get comments(): string;
2592
+ set comments(comments: string);
2593
+ constructor(candidate: Nullable<HTMLDivElement>, canvas: GraphCanvasComponent, doNotCaptureNodes?: boolean);
2594
+ refresh(): void;
2595
+ addNode(node: GraphNode): void;
2596
+ removeNode(node: GraphNode): void;
2597
+ syncNode(node: GraphNode): void;
2598
+ cleanAccumulation(): void;
2599
+ private _onDown;
2600
+ move(newX: number, newY: number, align?: boolean): void;
2601
+ private _onUp;
2602
+ _moveFrame(offsetX: number, offsetY: number): void;
2603
+ private _onMove;
2604
+ moveFramePortUp(nodePort: FrameNodePort): void;
2605
+ private _movePortUp;
2606
+ moveFramePortDown(nodePort: FrameNodePort): void;
2607
+ private _movePortDown;
2608
+ private _initResizing;
2609
+ private _cleanUpResizing;
2610
+ private _updateMinHeightWithComments;
2611
+ private _isResizingTop;
2612
+ private _isResizingRight;
2613
+ private _isResizingBottom;
2614
+ private _isResizingLeft;
2615
+ private _onRightHandlePointerDown;
2616
+ private _onRightHandlePointerMove;
2617
+ private _moveRightHandle;
2618
+ private _onRightHandlePointerUp;
2619
+ private _onBottomHandlePointerDown;
2620
+ private _onBottomHandlePointerMove;
2621
+ private _moveBottomHandle;
2622
+ private _onBottomHandlePointerUp;
2623
+ private _onLeftHandlePointerDown;
2624
+ private _onLeftHandlePointerMove;
2625
+ private _moveLeftHandle;
2626
+ private _onLeftHandlePointerUp;
2627
+ private _onTopHandlePointerDown;
2628
+ private _onTopHandlePointerMove;
2629
+ private _moveTopHandle;
2630
+ private _onTopHandlePointerUp;
2631
+ private _onTopRightHandlePointerDown;
2632
+ private _onTopRightHandlePointerMove;
2633
+ private _moveTopRightHandle;
2634
+ private _onTopRightHandlePointerUp;
2635
+ private _onBottomRightHandlePointerDown;
2636
+ private _onBottomRightHandlePointerMove;
2637
+ private _moveBottomRightHandle;
2638
+ private _onBottomRightHandlePointerUp;
2639
+ private _onBottomLeftHandlePointerDown;
2640
+ private _onBottomLeftHandlePointerMove;
2641
+ private _moveBottomLeftHandle;
2642
+ private _onBottomLeftHandlePointerUp;
2643
+ private _onTopLeftHandlePointerDown;
2644
+ private _onTopLeftHandlePointerMove;
2645
+ private _moveTopLeftHandle;
2646
+ private _onTopLeftHandlePointerUp;
2647
+ private _expandLeft;
2648
+ private _expandTop;
2649
+ private _expandRight;
2650
+ private _expandBottom;
2651
+ dispose(): void;
2652
+ private _serializePortData;
2653
+ serialize(saveCollapsedState: boolean): IFrameData;
2654
+ export(): void;
2655
+ adjustPorts(): void;
2656
+ static Parse(serializationData: IFrameData, canvas: GraphCanvasComponent, map?: {
2657
+ [key: number]: number;
2658
+ }): GraphFrame;
2659
+ }
2660
+
2661
+ }
2662
+ declare module "@babylonjs/gui-editor/nodeGraphSystem/graphNode" {
2663
+ /// <reference types="react" />
2664
+ import { Nullable } from "@babylonjs/core/types";
2665
+ import { GraphCanvasComponent } from "@babylonjs/gui-editor/nodeGraphSystem/graphCanvas";
2666
+ import { NodePort } from "@babylonjs/gui-editor/nodeGraphSystem/nodePort";
2667
+ import { GraphFrame } from "@babylonjs/gui-editor/nodeGraphSystem/graphFrame";
2668
+ import { NodeLink } from "@babylonjs/gui-editor/nodeGraphSystem/nodeLink";
2669
+ import { StateManager } from "@babylonjs/gui-editor/nodeGraphSystem/stateManager";
2670
+ import { INodeData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeData";
2671
+ import { IPortData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/portData";
2672
+ export class GraphNode {
2673
+ content: INodeData;
2674
+ private _visual;
2675
+ private _headerContainer;
2676
+ private _warning;
2677
+ private _header;
2678
+ private _connections;
2679
+ private _inputsContainer;
2680
+ private _outputsContainer;
2681
+ private _content;
2682
+ private _comments;
2683
+ private _inputPorts;
2684
+ private _outputPorts;
2685
+ private _links;
2686
+ private _x;
2687
+ private _y;
2688
+ private _gridAlignedX;
2689
+ private _gridAlignedY;
2690
+ private _mouseStartPointX;
2691
+ private _mouseStartPointY;
2692
+ private _stateManager;
2693
+ private _onSelectionChangedObserver;
2694
+ private _onSelectionBoxMovedObserver;
2695
+ private _onFrameCreatedObserver;
2696
+ private _onUpdateRequiredObserver;
2697
+ private _ownerCanvas;
2698
+ private _isSelected;
2699
+ private _displayManager;
2700
+ private _isVisible;
2701
+ private _enclosingFrameId;
2702
+ get isVisible(): boolean;
2703
+ set isVisible(value: boolean);
2704
+ private _upateNodePortNames;
2705
+ get outputPorts(): NodePort[];
2706
+ get inputPorts(): NodePort[];
2707
+ get links(): NodeLink[];
2708
+ get gridAlignedX(): number;
2709
+ get gridAlignedY(): number;
2710
+ get x(): number;
2711
+ set x(value: number);
2712
+ get y(): number;
2713
+ set y(value: number);
2714
+ get width(): number;
2715
+ get height(): number;
2716
+ get id(): number;
2717
+ get name(): string;
2718
+ get isSelected(): boolean;
2719
+ get enclosingFrameId(): number;
2720
+ set enclosingFrameId(value: number);
2721
+ set isSelected(value: boolean);
2722
+ setIsSelected(value: boolean, marqueeSelection: boolean): void;
2723
+ constructor(content: INodeData, stateManager: StateManager);
2724
+ isOverlappingFrame(frame: GraphFrame): boolean;
2725
+ getPortForPortData(portData: IPortData): NodePort | null;
2726
+ getPortDataForPortDataContent(data: any): IPortData | null;
2727
+ getLinksForPortDataContent(data: any): NodeLink[];
2728
+ getLinksForPortData(portData: IPortData): NodeLink[];
2729
+ private _refreshFrames;
2730
+ _refreshLinks(): void;
2731
+ refresh(): void;
2732
+ private _onDown;
2733
+ cleanAccumulation(useCeil?: boolean): void;
2734
+ private _onUp;
2735
+ private _onMove;
2736
+ renderProperties(): Nullable<JSX.Element>;
2737
+ appendVisual(root: HTMLDivElement, owner: GraphCanvasComponent): void;
2738
+ dispose(): void;
2739
+ }
2740
+
2741
+ }
2742
+ declare module "@babylonjs/gui-editor/nodeGraphSystem/interfaces/displayManager" {
2743
+ import { INodeData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeData";
2744
+ import { IPortData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/portData";
2745
+ export interface IDisplayManager {
2746
+ getHeaderClass(data: INodeData): string;
2747
+ shouldDisplayPortLabels(data: IPortData): boolean;
2748
+ updatePreviewContent(data: INodeData, contentArea: HTMLDivElement): void;
2749
+ getBackgroundColor(data: INodeData): string;
2750
+ getHeaderText(data: INodeData): string;
2751
+ }
2752
+
2753
+ }
2754
+ declare module "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeContainer" {
2755
+ import { GraphNode } from "@babylonjs/gui-editor/nodeGraphSystem/graphNode";
2756
+ import { INodeData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeData";
2757
+ export interface INodeContainer {
2758
+ nodes: GraphNode[];
2759
+ appendNode(data: INodeData): GraphNode;
2760
+ }
2761
+
2762
+ }
2763
+ declare module "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeData" {
2764
+ import { Nullable } from "@babylonjs/core/types";
2765
+ import { IPortData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/portData";
2766
+ export interface INodeData {
2767
+ data: any;
2768
+ name: string;
2769
+ uniqueId: number;
2770
+ isInput: boolean;
2771
+ comments: string;
2772
+ getWarningMessage: () => string;
2773
+ getClassName: () => string;
2774
+ dispose: () => void;
2775
+ getPortByName: (name: string) => Nullable<IPortData>;
2776
+ inputs: IPortData[];
2777
+ outputs: IPortData[];
2778
+ }
2779
+
2780
+ }
2781
+ declare module "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeLocationInfo" {
2782
+ export interface INodeLocationInfo {
2783
+ blockId: number;
2784
+ x: number;
2785
+ y: number;
2786
+ }
2787
+ export interface IFrameData {
2788
+ x: number;
2789
+ y: number;
2790
+ width: number;
2791
+ height: number;
2792
+ color: number[];
2793
+ name: string;
2794
+ isCollapsed: boolean;
2795
+ blocks: number[];
2796
+ comments: string;
2797
+ }
2798
+ export interface IEditorData {
2799
+ locations: INodeLocationInfo[];
2800
+ x: number;
2801
+ y: number;
2802
+ zoom: number;
2803
+ frames?: IFrameData[];
2804
+ map?: {
2805
+ [key: number]: number;
2806
+ };
2807
+ }
2808
+
2809
+ }
2810
+ declare module "@babylonjs/gui-editor/nodeGraphSystem/interfaces/portData" {
2811
+ import { Nullable } from "@babylonjs/core/types";
2812
+ import { GraphNode } from "@babylonjs/gui-editor/nodeGraphSystem/graphNode";
2813
+ export enum PortDataDirection {
2814
+ /** Input */
2815
+ Input = 0,
2816
+ /** Output */
2817
+ Output = 1
2818
+ }
2819
+ export interface IPortData {
2820
+ data: any;
2821
+ name: string;
2822
+ internalName: string;
2823
+ isExposedOnFrame: boolean;
2824
+ exposedPortPosition: number;
2825
+ isConnected: boolean;
2826
+ direction: PortDataDirection;
2827
+ ownerData: any;
2828
+ connectedPort: Nullable<IPortData>;
2829
+ needDualDirectionValidation: boolean;
2830
+ hasEndpoints: boolean;
2831
+ endpoints: Nullable<IPortData[]>;
2832
+ updateDisplayName: (newName: string) => void;
2833
+ connectTo: (port: IPortData) => void;
2834
+ disconnectFrom: (port: IPortData) => void;
2835
+ checkCompatibilityState(port: IPortData): number;
2836
+ getCompatibilityIssueMessage(issue: number, targetNode: GraphNode, targetPort: IPortData): string;
2837
+ }
2838
+
2839
+ }
2840
+ declare module "@babylonjs/gui-editor/nodeGraphSystem/interfaces/propertyComponentProps" {
2841
+ import { StateManager } from "@babylonjs/gui-editor/nodeGraphSystem/stateManager";
2842
+ import { INodeData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeData";
2843
+ export interface IPropertyComponentProps {
2844
+ stateManager: StateManager;
2845
+ nodeData: INodeData;
2846
+ }
2847
+
2848
+ }
2849
+ declare module "@babylonjs/gui-editor/nodeGraphSystem/interfaces/selectionChangedOptions" {
2850
+ import { Nullable } from "@babylonjs/core/types";
2851
+ import { GraphFrame } from "@babylonjs/gui-editor/nodeGraphSystem/graphFrame";
2852
+ import { GraphNode } from "@babylonjs/gui-editor/nodeGraphSystem/graphNode";
2853
+ import { NodeLink } from "@babylonjs/gui-editor/nodeGraphSystem/nodeLink";
2854
+ import { NodePort } from "@babylonjs/gui-editor/nodeGraphSystem/nodePort";
2855
+ import { FramePortData } from "@babylonjs/gui-editor/nodeGraphSystem/types/framePortData";
2856
+ export interface ISelectionChangedOptions {
2857
+ selection: Nullable<GraphNode | NodeLink | GraphFrame | NodePort | FramePortData>;
2858
+ forceKeepSelection?: boolean;
2859
+ marqueeSelection?: boolean;
2860
+ }
2861
+
2862
+ }
2863
+ declare module "@babylonjs/gui-editor/nodeGraphSystem/nodeLink" {
2864
+ import { Observable } from "@babylonjs/core/Misc/observable";
2865
+ import { FrameNodePort } from "@babylonjs/gui-editor/nodeGraphSystem/frameNodePort";
2866
+ import { NodePort } from "@babylonjs/gui-editor/nodeGraphSystem/nodePort";
2867
+ import { GraphNode } from "@babylonjs/gui-editor/nodeGraphSystem/graphNode";
2868
+ import { GraphCanvasComponent } from "@babylonjs/gui-editor/nodeGraphSystem/graphCanvas";
2869
+ export class NodeLink {
2870
+ private _graphCanvas;
2871
+ private _portA;
2872
+ private _portB?;
2873
+ private _nodeA;
2874
+ private _nodeB?;
2875
+ private _path;
2876
+ private _selectionPath;
2877
+ private _onSelectionChangedObserver;
2878
+ private _isVisible;
2879
+ onDisposedObservable: Observable<NodeLink>;
2880
+ get isVisible(): boolean;
2881
+ set isVisible(value: boolean);
2882
+ get portA(): FrameNodePort | NodePort;
2883
+ get portB(): FrameNodePort | NodePort | undefined;
2884
+ get nodeA(): GraphNode;
2885
+ get nodeB(): GraphNode | undefined;
2886
+ update(endX?: number, endY?: number, straight?: boolean): void;
2887
+ constructor(graphCanvas: GraphCanvasComponent, portA: NodePort, nodeA: GraphNode, portB?: NodePort, nodeB?: GraphNode);
2888
+ onClick(evt: MouseEvent): void;
2889
+ dispose(notify?: boolean): void;
2890
+ }
2891
+
2892
+ }
2893
+ declare module "@babylonjs/gui-editor/nodeGraphSystem/nodePort" {
2894
+ import { Nullable } from "@babylonjs/core/types";
2895
+ import { Observer } from "@babylonjs/core/Misc/observable";
2896
+ import { Vector2 } from "@babylonjs/core/Maths/math.vector";
2897
+ import { GraphNode } from "@babylonjs/gui-editor/nodeGraphSystem/graphNode";
2898
+ import { StateManager } from "@babylonjs/gui-editor/nodeGraphSystem/stateManager";
2899
+ import { ISelectionChangedOptions } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/selectionChangedOptions";
2900
+ import { FrameNodePort } from "@babylonjs/gui-editor/nodeGraphSystem/frameNodePort";
2901
+ import { IDisplayManager } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/displayManager";
2902
+ import { IPortData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/portData";
2903
+ export class NodePort {
2904
+ portData: IPortData;
2905
+ node: GraphNode;
2906
+ protected _element: HTMLDivElement;
2907
+ protected _img: HTMLImageElement;
2908
+ protected _stateManager: StateManager;
2909
+ protected _portLabelElement: Element;
2910
+ protected _onCandidateLinkMovedObserver: Nullable<Observer<Nullable<Vector2>>>;
2911
+ protected _onSelectionChangedObserver: Nullable<Observer<Nullable<ISelectionChangedOptions>>>;
2912
+ protected _exposedOnFrame: boolean;
2913
+ delegatedPort: Nullable<FrameNodePort>;
2914
+ get element(): HTMLDivElement;
2915
+ get portName(): string;
2916
+ set portName(newName: string);
2917
+ get disabled(): boolean;
2918
+ hasLabel(): boolean;
2919
+ get exposedOnFrame(): boolean;
2920
+ set exposedOnFrame(value: boolean);
2921
+ get exposedPortPosition(): number;
2922
+ set exposedPortPosition(value: number);
2923
+ private _isConnectedToNodeOutsideOfFrame;
2924
+ refresh(): void;
2925
+ constructor(portContainer: HTMLElement, portData: IPortData, node: GraphNode, stateManager: StateManager);
2926
+ dispose(): void;
2927
+ static CreatePortElement(portData: IPortData, node: GraphNode, root: HTMLElement, displayManager: Nullable<IDisplayManager>, stateManager: StateManager): NodePort;
2928
+ }
2929
+
2930
+ }
2931
+ declare module "@babylonjs/gui-editor/nodeGraphSystem/propertyLedger" {
2932
+ import { ComponentClass } from "react";
2933
+ import { IPropertyComponentProps } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/propertyComponentProps";
2934
+ export class PropertyLedger {
2935
+ static DefaultControl: ComponentClass<IPropertyComponentProps>;
2936
+ static RegisteredControls: {
2937
+ [key: string]: ComponentClass<IPropertyComponentProps>;
2938
+ };
2939
+ }
2940
+
2941
+ }
2942
+ declare module "@babylonjs/gui-editor/nodeGraphSystem/stateManager" {
2943
+ import { Vector2 } from "@babylonjs/core/Maths/math.vector";
2944
+ import { Observable } from "@babylonjs/core/Misc/observable";
2945
+ import { Nullable } from "@babylonjs/core/types";
2946
+ import { FrameNodePort } from "@babylonjs/gui-editor/nodeGraphSystem/frameNodePort";
2947
+ import { GraphFrame } from "@babylonjs/gui-editor/nodeGraphSystem/graphFrame";
2948
+ import { GraphNode } from "@babylonjs/gui-editor/nodeGraphSystem/graphNode";
2949
+ import { INodeContainer } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeContainer";
2950
+ import { INodeData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeData";
2951
+ import { IPortData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/portData";
2952
+ import { ISelectionChangedOptions } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/selectionChangedOptions";
2953
+ import { NodePort } from "@babylonjs/gui-editor/nodeGraphSystem/nodePort";
2954
+ export class StateManager {
2955
+ data: any;
2956
+ hostDocument: Document;
2957
+ lockObject: any;
2958
+ onSelectionChangedObservable: Observable<Nullable<ISelectionChangedOptions>>;
2959
+ onFrameCreatedObservable: Observable<GraphFrame>;
2960
+ onUpdateRequiredObservable: Observable<any>;
2961
+ onGraphNodeRemovalObservable: Observable<GraphNode>;
2962
+ onSelectionBoxMoved: Observable<ClientRect | DOMRect>;
2963
+ onCandidateLinkMoved: Observable<Nullable<Vector2>>;
2964
+ onCandidatePortSelectedObservable: Observable<Nullable<FrameNodePort | NodePort>>;
2965
+ onNewNodeCreatedObservable: Observable<GraphNode>;
2966
+ onRebuildRequiredObservable: Observable<boolean>;
2967
+ onErrorMessageDialogRequiredObservable: Observable<string>;
2968
+ onExposePortOnFrameObservable: Observable<GraphNode>;
2969
+ onGridSizeChanged: Observable<void>;
2970
+ onNewBlockRequiredObservable: Observable<{
2971
+ type: string;
2972
+ targetX: number;
2973
+ targetY: number;
2974
+ needRepositioning?: boolean | undefined;
2975
+ }>;
2976
+ exportData: (data: any) => string;
2977
+ isElbowConnectionAllowed: (nodeA: FrameNodePort | NodePort, nodeB: FrameNodePort | NodePort) => boolean;
2978
+ applyNodePortDesign: (data: IPortData, element: HTMLElement, img: HTMLImageElement) => void;
2979
+ storeEditorData: (serializationObject: any, frame?: Nullable<GraphFrame>) => void;
2980
+ getEditorDataMap: () => {
2981
+ [key: number]: number;
2982
+ };
2983
+ createDefaultInputData: (rootData: any, portData: IPortData, nodeContainer: INodeContainer) => {
2984
+ data: INodeData;
2985
+ name: string;
2986
+ };
2987
+ }
2988
+
2989
+ }
2990
+ declare module "@babylonjs/gui-editor/nodeGraphSystem/tools" {
2991
+ import { GraphNode } from "@babylonjs/gui-editor/nodeGraphSystem/graphNode";
2992
+ import { NodeLink } from "@babylonjs/gui-editor/nodeGraphSystem/nodeLink";
2993
+ import { FramePortData } from "@babylonjs/gui-editor/nodeGraphSystem/types/framePortData";
2994
+ export const IsFramePortData: (variableToCheck: any) => variableToCheck is FramePortData;
2995
+ export const RefreshNode: (node: GraphNode, visitedNodes?: Set<GraphNode> | undefined, visitedLinks?: Set<NodeLink> | undefined) => void;
2996
+
2997
+ }
2998
+ declare module "@babylonjs/gui-editor/nodeGraphSystem/typeLedger" {
2999
+ import { INodeContainer } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeContainer";
3000
+ import { INodeData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/nodeData";
3001
+ import { IPortData } from "@babylonjs/gui-editor/nodeGraphSystem/interfaces/portData";
3002
+ import { NodePort } from "@babylonjs/gui-editor/nodeGraphSystem/nodePort";
3003
+ export class TypeLedger {
3004
+ static PortDataBuilder: (port: NodePort, nodeContainer: INodeContainer) => IPortData;
3005
+ static NodeDataBuilder: (data: any, nodeContainer: INodeContainer) => INodeData;
3006
+ }
3007
+
3008
+ }
3009
+ declare module "@babylonjs/gui-editor/nodeGraphSystem/types/framePortData" {
3010
+ import { GraphFrame } from "@babylonjs/gui-editor/nodeGraphSystem/graphFrame";
3011
+ import { FrameNodePort } from "@babylonjs/gui-editor/nodeGraphSystem/frameNodePort";
3012
+ export type FramePortData = {
3013
+ frame: GraphFrame;
3014
+ port: FrameNodePort;
3015
+ };
3016
+ export {};
3017
+
2318
3018
  }
2319
3019
  declare module "@babylonjs/gui-editor/propertyChangedEvent" {
2320
3020
  export class PropertyChangedEvent {