babylonjs-editor 4.4.0 → 5.2.4

package/build/src/index.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const os_1 = require("os");
+const electron_updater_1 = require("electron-updater");
+const posix_1 = require("path/posix");
+const electron_1 = require("electron");
+const process_1 = require("./tools/process");
+const menu_1 = require("./editor/menu");
+const menu_2 = require("./dashboard/menu");
+const window_1 = require("./dashboard/window");
+const window_2 = require("./editor/window");
+require("./electron/node-pty");
+require("./electron/events/shell");
+require("./electron/events/dialog");
+require("./electron/events/editor");
+require("./electron/events/window");
+require("./electron/assimp/assimpjs");
+require("./electron/events/export");
+try {
+    if (!electron_1.app.isPackaged) {
+        process.env.DEBUG ??= "true";
+    }
+    if (process.env.DEBUG) {
+        require("electron-reloader")(module);
+    }
+}
+catch (_) {
+    /* Catch silently */
+}
+// Enable remote debugging of both the Editor and the edited Project.
+electron_1.app.commandLine.appendSwitch("remote-debugging-port", "8315");
+// Force dedicated GPU on systems with dual graphics cards (typically laptops).
+electron_1.app.commandLine.appendSwitch("force_high_performance_gpu");
+electron_1.app.addListener("ready", async () => {
+    electron_1.nativeTheme.themeSource = "system";
+    electron_1.globalShortcut.register("CommandOrControl+ALT+I", () => {
+        electron_1.BrowserWindow.getFocusedWindow()?.webContents.openDevTools({
+            mode: "right",
+        });
+    });
+    const filePath = (0, process_1.getFilePathArgument)(process.argv);
+    if (filePath) {
+        await openProject(filePath);
+    }
+    else {
+        await openDashboard();
+    }
+    electron_updater_1.autoUpdater.checkForUpdatesAndNotify();
+});
+electron_1.app.on("window-all-closed", () => {
+    if (process.platform !== "darwin") {
+        electron_1.app.quit();
+    }
+});
+electron_1.app.on("activate", () => {
+    if (electron_1.BrowserWindow.getAllWindows().length === 0) {
+        openDashboard();
+    }
+});
+electron_1.app.on("second-instance", async () => {
+    if ((0, os_1.platform)() === "darwin") {
+        const window = await openDashboard();
+        console.log(window); // TODO: setup new window (aka new project).
+    }
+});
+let shouldAppQuit = false;
+electron_1.ipcMain.on("app:quit", () => {
+    for (const window of window_2.editorWindows.slice()) {
+        window.close();
+        if (window_2.editorWindows.includes(window)) {
+            return;
+        }
+    }
+    if (!window_2.editorWindows.length) {
+        shouldAppQuit = true;
+        electron_1.app.quit();
+    }
+});
+let dashboardWindow = null;
+async function openDashboard() {
+    if (!dashboardWindow) {
+        (0, menu_2.setupDashboardMenu)();
+        dashboardWindow = await (0, window_1.createDashboardWindow)();
+        dashboardWindow.setTitle("Dashboard");
+        dashboardWindow.on("focus", () => (0, menu_2.setupDashboardMenu)());
+        dashboardWindow.on("closed", () => (dashboardWindow = null));
+    }
+    dashboardWindow.show();
+    dashboardWindow.focus();
+}
+function closeDashboard() {
+    if (dashboardWindow) {
+        dashboardWindow.close();
+        dashboardWindow = null;
+    }
+}
+electron_1.ipcMain.on("dashboard:open-project", (_, file, shouldCloseDashboard) => {
+    openProject(file);
+    dashboardWindow?.minimize();
+    if (shouldCloseDashboard) {
+        closeDashboard();
+    }
+});
+electron_1.ipcMain.on("dashboard:update-projects", () => {
+    dashboardWindow?.webContents.send("dashboard:update-projects");
+});
+const openedProjects = [];
+async function openProject(filePath) {
+    if (openedProjects.includes(filePath)) {
+        return;
+    }
+    openedProjects.push(filePath);
+    notifyWindows("dashboard:opened-projects", openedProjects);
+    (0, menu_1.setupEditorMenu)();
+    const window = await (0, window_2.createEditorWindow)();
+    window.setTitle((0, posix_1.basename)((0, posix_1.dirname)(filePath)));
+    window.on("focus", () => (0, menu_1.setupEditorMenu)());
+    window.once("closed", () => {
+        openedProjects.splice(openedProjects.indexOf(filePath), 1);
+        notifyWindows("dashboard:opened-projects", openedProjects);
+        if (openedProjects.length === 0 && !shouldAppQuit) {
+            openDashboard();
+        }
+    });
+    if (filePath) {
+        window.maximize();
+    }
+    if (filePath) {
+        window.webContents.send("editor:open", filePath);
+        window.webContents.send("editor:path", (0, posix_1.join)(electron_1.app.getAppPath()));
+        window.webContents.on("did-finish-load", () => {
+            window.webContents.send("editor:open", filePath);
+            window.webContents.send("editor:path", (0, posix_1.join)(electron_1.app.getAppPath()));
+        });
+    }
+}
+function notifyWindows(event, data) {
+    electron_1.BrowserWindow.getAllWindows().forEach((window) => {
+        window.webContents.send(event, data);
+    });
+}
+//# sourceMappingURL=index.js.map

package/declaration/src/dashboard/create.d.ts

@@ -0,0 +1,6 @@
+export interface IDashboardCreateProjectDialogProps {
+    isOpened: boolean;
+    closeDashboardOnProjectOpen: boolean;
+    onClose: () => void;
+}
+export declare function DashboardCreateProjectDialog(props: IDashboardCreateProjectDialogProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/dashboard/item.d.ts

@@ -0,0 +1,8 @@
+import { ProjectType } from "../tools/project";
+export interface IDashboardProjectItemProps {
+    isOpened: boolean;
+    project: ProjectType;
+    closeDashboardOnProjectOpen: boolean;
+    onRemove: () => void;
+}
+export declare function DashboardProjectItem(props: IDashboardProjectItemProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/dashboard/main.d.ts

@@ -0,0 +1,19 @@
+import { Component, ReactNode } from "react";
+import { ProjectType } from "../tools/project";
+export declare function createDashboard(): void;
+export interface IDashboardProps {
+}
+export interface IDashboardState {
+    projects: ProjectType[];
+    openedProjects: string[];
+    createProject: boolean;
+    closeDashboardOnProjectOpen: boolean;
+}
+export declare class Dashboard extends Component<IDashboardProps, IDashboardState> {
+    constructor(props: IDashboardProps);
+    render(): ReactNode;
+    componentDidMount(): Promise<void>;
+    private _checkSystemAvailabilities;
+    private _handleImportProject;
+    private _tryRemoveProjectFromLocalStorage;
+}

package/declaration/src/dashboard/menu.d.ts

@@ -0,0 +1 @@
+export declare function setupDashboardMenu(): void;

package/declaration/src/dashboard/progress.d.ts

@@ -0,0 +1,17 @@
+import { Component, ReactNode } from "react";
+import { NodePtyInstance } from "../tools/node-pty";
+export interface IDashboardProgressComponentProps {
+    name: string;
+}
+export interface IDashboardProgressComponentState {
+    message: ReactNode;
+}
+export declare class DashboardProgressComponent extends Component<IDashboardProgressComponentProps, IDashboardProgressComponentState> {
+    private _terminal;
+    private _fitAddon;
+    private _terminalData;
+    constructor(props: IDashboardProgressComponentProps);
+    render(): ReactNode;
+    private _onTerminalDivChanged;
+    setProcess(process: NodePtyInstance): void;
+}

package/declaration/src/dashboard/window-controls.d.ts

@@ -0,0 +1 @@
+export declare function DashboardWindowControls(): import("react/jsx-runtime").JSX.Element;

package/declaration/src/dashboard/window.d.ts

@@ -0,0 +1,2 @@
+import { BrowserWindow } from "electron";
+export declare function createDashboardWindow(): Promise<BrowserWindow>;

package/declaration/src/editor/dialogs/command-palette/camera.d.ts

@@ -0,0 +1,4 @@
+import { Node } from "babylonjs";
+import { Editor } from "../../main";
+import { ICommandPaletteType } from "./command-palette";
+export declare function getCameraCommands(editor?: Editor, parent?: Node): ICommandPaletteType[];

package/declaration/src/editor/dialogs/command-palette/command-palette.d.ts

@@ -0,0 +1,27 @@
+import { Component, ReactNode } from "react";
+import { Editor } from "../../main";
+export interface ICommandPaletteProps {
+    editor: Editor;
+}
+export interface ICommandPaletteState {
+    open: boolean;
+    query: string;
+    files: ICommandPaletteType[];
+    entities: ICommandPaletteType[];
+}
+export interface ICommandPaletteType {
+    text: string;
+    key: string;
+    label: string;
+    disabled?: boolean;
+    ipcRendererChannelKey?: string;
+    action: () => unknown;
+}
+export declare class CommandPalette extends Component<ICommandPaletteProps, ICommandPaletteState> {
+    constructor(props: ICommandPaletteProps);
+    render(): ReactNode;
+    setOpen(open: boolean): void;
+    private _executeCommand;
+    private _refreshEntities;
+    private _refreshAssetFiles;
+}

package/declaration/src/editor/dialogs/command-palette/light.d.ts

@@ -0,0 +1,4 @@
+import { Node } from "babylonjs";
+import { Editor } from "../../main";
+import { ICommandPaletteType } from "./command-palette";
+export declare function getLightCommands(editor?: Editor, parent?: Node): ICommandPaletteType[];

package/declaration/src/editor/dialogs/command-palette/material.d.ts

@@ -0,0 +1,4 @@
+import { Editor } from "../../main";
+import { ICommandPaletteType } from "./command-palette";
+export declare function getMaterialCommands(editor?: Editor): ICommandPaletteType[];
+export declare function getMaterialsLibraryCommands(editor?: Editor): ICommandPaletteType[];

package/declaration/src/editor/dialogs/command-palette/mesh.d.ts

@@ -0,0 +1,4 @@
+import { Node } from "babylonjs";
+import { Editor } from "../../main";
+import { ICommandPaletteType } from "./command-palette";
+export declare function getMeshCommands(editor?: Editor, parent?: Node): ICommandPaletteType[];

package/declaration/src/editor/dialogs/command-palette/node.d.ts

@@ -0,0 +1,4 @@
+import { Node } from "babylonjs";
+import { Editor } from "../../main";
+import { ICommandPaletteType } from "./command-palette";
+export declare function getNodeCommands(editor?: Editor, parent?: Node): ICommandPaletteType[];

package/declaration/src/editor/dialogs/command-palette/particle-systems.d.ts

@@ -0,0 +1,3 @@
+import { Editor } from "../../main";
+import { ICommandPaletteType } from "./command-palette";
+export declare function getParticleSystemsCommands(editor: Editor): ICommandPaletteType[];

package/declaration/src/editor/dialogs/command-palette/project.d.ts

@@ -0,0 +1,3 @@
+import { Editor } from "../../main";
+import { ICommandPaletteType } from "./command-palette";
+export declare function getProjectCommands(editor: Editor): ICommandPaletteType[];

package/declaration/src/editor/dialogs/command-palette/shared-commands.d.ts

@@ -0,0 +1,31 @@
+import { ICommandPaletteType } from "./command-palette";
+export type CommandItem = Omit<ICommandPaletteType, "action">;
+export declare const cameraCommandItems: {
+    freeCamera: CommandItem;
+    arcRotateCamera: CommandItem;
+};
+export declare const lightCommandItems: {
+    pointLight: CommandItem;
+    directionalLight: CommandItem;
+    spotLight: CommandItem;
+    hemisphericLight: CommandItem;
+};
+export declare const nodeCommandItems: {
+    transformNode: CommandItem;
+};
+export declare const meshCommandItems: {
+    box: CommandItem;
+    plane: CommandItem;
+    ground: CommandItem;
+    sphere: CommandItem;
+    capsule: CommandItem;
+    cylinder: CommandItem;
+    torus: CommandItem;
+    torusKnot: CommandItem;
+    skybox: CommandItem;
+    emptyMesh: CommandItem;
+};
+export declare const spriteCommandItems: {
+    spriteManager: CommandItem;
+    spriteMap: CommandItem;
+};

package/declaration/src/editor/dialogs/command-palette/sprite.d.ts

@@ -0,0 +1,4 @@
+import { Node } from "babylonjs";
+import { Editor } from "../../main";
+import { ICommandPaletteType } from "./command-palette";
+export declare function getSpriteCommands(editor?: Editor, parent?: Node): ICommandPaletteType[];

package/declaration/src/editor/dialogs/edit-preferences/edit-preferences.d.ts

@@ -0,0 +1,24 @@
+import { Component, ReactNode } from "react";
+import { Editor } from "../../main";
+export interface IEditorEditPreferencesComponentProps {
+    /**
+     * Defines the editor reference.
+     */
+    editor: Editor;
+    /**
+     * Defines if the dialog is open.
+     */
+    open: boolean;
+    onClose: () => void;
+}
+export interface IEditorEditPreferencesComponentState {
+    theme: "light" | "dark";
+}
+export declare class EditorEditPreferencesComponent extends Component<IEditorEditPreferencesComponentProps, IEditorEditPreferencesComponentState> {
+    constructor(props: IEditorEditPreferencesComponentProps);
+    render(): ReactNode;
+    private _getThemesComponent;
+    private _getCameraControlPreferences;
+    private _saveCameraControls;
+    private _getExperimentalComponent;
+}

package/declaration/src/editor/dialogs/edit-project/edit-project.d.ts

@@ -0,0 +1,17 @@
+import { Component, ReactNode } from "react";
+import { Editor } from "../../main";
+export interface IEditorEditProjectComponentProps {
+    /**
+     * Defines the editor reference.
+     */
+    editor: Editor;
+    /**
+     * Defines if the dialog is open.
+     */
+    open: boolean;
+    onClose: () => void;
+}
+export declare class EditorEditProjectComponent extends Component<IEditorEditProjectComponentProps> {
+    render(): ReactNode;
+    private _handleSave;
+}

package/declaration/src/editor/dialogs/edit-project/plugins/component.d.ts

@@ -0,0 +1,18 @@
+import { Component, ReactNode } from "react";
+import { Editor } from "../../../main";
+export interface IEditorEditProjectPluginComponentProps {
+    /**
+     * Defines the editor reference.
+     */
+    editor: Editor;
+}
+export interface IEditorEditProjectPluginComponentState {
+    installing: boolean;
+}
+export declare class EditorEditProjectPluginComponent extends Component<IEditorEditProjectPluginComponentProps, IEditorEditProjectPluginComponentState> {
+    constructor(props: IEditorEditProjectPluginComponentProps);
+    render(): ReactNode;
+    private _handleAddPluginFromNpm;
+    private _handleAddPluginFromLocalDisk;
+    private _handlePluginRemoved;
+}

package/declaration/src/editor/dialogs/edit-project/plugins/item.d.ts

@@ -0,0 +1,7 @@
+import { Editor } from "../../../main";
+export interface IEditorEditProjectPluginComponentProps {
+    editor: Editor;
+    pathOrName: string;
+    onRemoved: () => void;
+}
+export declare function EditorEditProjectPluginItemComponent(props: IEditorEditProjectPluginComponentProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/dialogs/edit-project/textures/component.d.ts

@@ -0,0 +1,9 @@
+import { Component, ReactNode } from "react";
+import { Editor } from "../../../main";
+export interface IEditorEditProjectTextureComponentProps {
+    editor: Editor;
+}
+export declare class EditorEditProjectTextureComponent extends Component<IEditorEditProjectTextureComponentProps> {
+    render(): ReactNode;
+    private _handleBrowsePVRTexToolCliPath;
+}

package/declaration/src/editor/layout/animation/inspector/inspector.d.ts

@@ -0,0 +1,21 @@
+import { Component, ReactNode } from "react";
+import { IAnimationKey } from "babylonjs";
+import { EditorAnimation } from "../../animation";
+export interface IEditorAnimationInspectorProps {
+    animationEditor: EditorAnimation;
+}
+export interface IEditorAnimationInspectorState {
+    key: IAnimationKey | null;
+}
+export declare class EditorAnimationInspector extends Component<IEditorAnimationInspectorProps, IEditorAnimationInspectorState> {
+    constructor(props: IEditorAnimationInspectorProps);
+    render(): ReactNode;
+    /**
+     * Sets the rerefence to the key to edit.
+     * @param key defines the reference to the key to edit.
+     */
+    setEditedKey(key: IAnimationKey | null): void;
+    private _getKeyInspector;
+    private _getTangentDefaultValue;
+    private _getTangentInspector;
+}

package/declaration/src/editor/layout/animation/timeline/key.d.ts

@@ -0,0 +1,24 @@
+import { Component, ReactNode } from "react";
+import { IAnimatable, IAnimationKey } from "babylonjs";
+import { EditorAnimation } from "../../animation";
+export interface IEditorAnimationTimelineKeyProps {
+    scale: number;
+    animatable: IAnimatable;
+    animationKey: IAnimationKey;
+    animationEditor: EditorAnimation;
+    onClicked: (key: IAnimationKey) => void;
+    onRemoved: (key: IAnimationKey) => void;
+    onMoved: (movedKeys: IAnimationKeyConfigurationToMove[][]) => void;
+}
+export interface IEditorAnimationTimelineKeyState {
+    moving: boolean | undefined;
+}
+export interface IAnimationKeyConfigurationToMove {
+    key: IAnimationKey;
+    startPosition: number;
+}
+export declare class EditorAnimationTimelineKey extends Component<IEditorAnimationTimelineKeyProps, IEditorAnimationTimelineKeyState> {
+    constructor(props: IEditorAnimationTimelineKeyProps);
+    render(): ReactNode;
+    private _handlePointerDown;
+}

package/declaration/src/editor/layout/animation/timeline/timeline.d.ts

@@ -0,0 +1,68 @@
+import { Component, ReactNode } from "react";
+import { Animation, IAnimatable } from "babylonjs";
+import { Editor } from "../../../main";
+import { EditorAnimation } from "../../animation";
+import { EditorAnimationTimelineItem } from "./track";
+export interface IEditorAnimationTimelinePanelProps {
+    editor: Editor;
+    animatable: IAnimatable | null;
+    animationEditor: EditorAnimation;
+}
+export interface IEditorAnimationTimelinePanelState {
+    scale: number;
+    moving: boolean;
+    currentTime: number;
+}
+export declare class EditorAnimationTimelinePanel extends Component<IEditorAnimationTimelinePanelProps, IEditorAnimationTimelinePanelState> {
+    /**
+     * This class acts as an IAnimatable. This is used to animate the currentTime value on the state
+     * and be synchronized with the animations being edited and played by Babylon.js.
+     */
+    animations: Animation[];
+    /**
+     * Defines the list of all available track items in the timeline.
+     */
+    tracks: (EditorAnimationTimelineItem | null)[];
+    private _animation;
+    private _animatedCurrentTime;
+    private _renderLoop;
+    private _divRef;
+    constructor(props: IEditorAnimationTimelinePanelProps);
+    render(): ReactNode;
+    componentDidMount(): void;
+    private _getEmpty;
+    private _getEmptyAnimations;
+    private _getAnimationsList;
+    private _getMaxWidthForTimeline;
+    private _getMaxFrameForTimeline;
+    private _onWheelEvent;
+    /**
+     * Updates all the track using the current time as reference.
+     */
+    updateTracksAtCurrentTime(): void;
+    /**
+     * Sets the current time being edited in the timeline.
+     * @param currentTime defines the current time expressed in frame.
+     */
+    setCurrentTime(currentTime: number): void;
+    /**
+     * Sets the new scale of the timeline.
+     * @param scale defines the new scale value to apply on the timeline.
+     */
+    setScale(scale: number): void;
+    /**
+     * Adds a key at the current time for all tracks in the timeline.
+     * Checks for each track if a key already exists at the current time and if not, adds a new key.
+     * For the value, sets the current value of the animatable object property being animated.
+     */
+    addKeysAtCurrentTime(): void;
+    /**
+     * Plays the current timeline starting from the current tracker position.
+     */
+    play(): void;
+    /**
+     * Stops the current timeline being played
+     */
+    stop(): void;
+    private _handlePointerDown;
+}

package/declaration/src/editor/layout/animation/timeline/track.d.ts

@@ -0,0 +1,29 @@
+import { Component, ReactNode } from "react";
+import { Animation, IAnimatable } from "babylonjs";
+import { EditorAnimation } from "../../animation";
+import { EditorAnimationTimelineKey } from "./key";
+export interface IEditorAnimationTimelineItemProps {
+    scale: number;
+    currentTime: number;
+    animation: Animation;
+    animatable: IAnimatable | null;
+    animationEditor: EditorAnimation;
+}
+export interface IEditorAnimationTimelineItemState {
+    rightClickPositionX: number | null;
+}
+export declare class EditorAnimationTimelineItem extends Component<IEditorAnimationTimelineItemProps, IEditorAnimationTimelineItemState> {
+    /**
+     * Defines the list of all available key frames in the track.
+     */
+    keyFrames: (EditorAnimationTimelineKey | null)[];
+    constructor(props: IEditorAnimationTimelineItemProps);
+    render(): ReactNode;
+    /**
+     * Adds a new animation key for this track located at the current time selected in
+     * the animation editor using the time tracker.
+     */
+    addAnimationKey(positionX?: number | null): void;
+    private _onAnimationKeyMoved;
+    private _onAnimationKeyRemoved;
+}

package/declaration/src/editor/layout/animation/timeline/tracker.d.ts

@@ -0,0 +1,17 @@
+import { Component, ReactNode } from "react";
+export interface IEditorAnimationTrackerProps {
+    width: number;
+    scale: number;
+    currentTime: number;
+    onTimeChange: (currentTime: number) => void;
+}
+export interface IEditorAnimationTrackerState {
+    moving: boolean;
+}
+export declare class EditorAnimationTracker extends Component<IEditorAnimationTrackerProps, IEditorAnimationTrackerState> {
+    constructor(props: IEditorAnimationTrackerProps);
+    render(): ReactNode;
+    private _handleClick;
+    private _handlePointerDown;
+    private _getTooltipContent;
+}

package/declaration/src/editor/layout/animation/toolbar.d.ts

@@ -0,0 +1,11 @@
+import { Component, ReactNode } from "react";
+import { IAnimatable } from "babylonjs";
+import { EditorAnimation } from "../animation";
+export interface IEditorAnimationToolbarProps {
+    playing: boolean;
+    animatable: IAnimatable | null;
+    animationEditor: EditorAnimation;
+}
+export declare class EditorAnimationToolbar extends Component<IEditorAnimationToolbarProps> {
+    render(): ReactNode;
+}

package/declaration/src/editor/layout/animation/tools/export.d.ts

@@ -0,0 +1,2 @@
+import { IAnimatable } from "babylonjs";
+export declare function exportAnimationsAs(animatable: IAnimatable | null): Promise<import("../../../../ui/dialog").DialogReturnType | undefined>;

package/declaration/src/editor/layout/animation/tools/import.d.ts

@@ -0,0 +1,3 @@
+import { IAnimatable } from "babylonjs";
+import { EditorAnimation } from "../../animation";
+export declare function importAnimationsFrom(animationEditor: EditorAnimation, animatable: IAnimatable | null): Promise<void>;

package/declaration/src/editor/layout/animation/tools/properties.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns all the possible animatable properties for the given object.
+ * @param object defines the root object to check keys for animatable properties.
+ * @param deep defines how deep the search should traverse objects to get properties (a.b.c.d.etc.).
+ */
+export declare function getAllAnimatableProperties(object: any, deep?: number, _processedObjects?: any[]): string[];

package/declaration/src/editor/layout/animation/tracks/add.d.ts

@@ -0,0 +1,7 @@
+import { IAnimatable } from "babylonjs";
+export interface IEditorAnimationAddTrackPromptProps {
+    animatable: IAnimatable;
+    onSelectProperty: (property: string | null) => void;
+}
+export declare function showAddTrackPrompt(animatable: IAnimatable): Promise<string | null>;
+export declare function EditorAnimationAddTrackPrompt(props: IEditorAnimationAddTrackPromptProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/animation/tracks/item.d.ts

@@ -0,0 +1,11 @@
+import { Component, ReactNode } from "react";
+import { Animation } from "babylonjs";
+import { EditorAnimation } from "../../animation";
+export interface IEditorAnimationTrackItemProps {
+    animation: Animation;
+    animationEditor: EditorAnimation;
+    onRemove: (animation: Animation) => void;
+}
+export declare class EditorAnimationTrackItem extends Component<IEditorAnimationTrackItemProps> {
+    render(): ReactNode;
+}

package/declaration/src/editor/layout/animation/tracks/tracks.d.ts

@@ -0,0 +1,18 @@
+import { Component, ReactNode } from "react";
+import { IAnimatable } from "babylonjs";
+import { EditorAnimation } from "../../animation";
+export interface IEditorAnimationTracksPanelProps {
+    animatable: IAnimatable | null;
+    animationEditor: EditorAnimation;
+}
+export declare class EditorAnimationTracksPanel extends Component<IEditorAnimationTracksPanelProps> {
+    render(): ReactNode;
+    private _getEmpty;
+    private _getAnimationsList;
+    /**
+     * Shows a prompt to add a new track to the animatable object.
+     * Aka. animate a property on the currently selected animatable.
+     */
+    addTrack(): Promise<unknown>;
+    private _handleRemoveTrack;
+}