@datalayer/core 0.0.1 → 0.0.2

package/lib/components/runtimes/RuntimeUtils.js

@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+import { PathExt } from '@jupyterlab/coreutils';
+import { nullTranslator } from '@jupyterlab/translation';
+const ASSIGN_NEW_RUNTIME_LABEL = 'Assign a new Runtime';
+const ASSIGN_EXISTING_REMOTE_RUNTIME_LABEL = 'Assign an existing Remote Runtime';
+const ASSIGN_EXISTING_RUNTIME_LABEL = 'Assign an existing Runtime';
+/**
+ * Create the grouped runtime descriptions.
+ */
+export function getGroupedRuntimeDescs(multiServiceManager, kernelId, translator, filterKernels = () => true, variant) {
+    translator = translator ?? nullTranslator;
+    const trans = translator.load('jupyterlab');
+    const specs = multiServiceManager.local.kernelspecs.specs;
+    const sessions = multiServiceManager.local.sessions.running();
+    const kernels = {};
+    // Add the sessions.
+    const runningSessions = Array.from(sessions)
+        .filter(session => session.kernel &&
+        session.kernel.id !== kernelId &&
+        specs.kernelspecs[session.kernel.name])
+        .map(session => {
+        const spec = specs.kernelspecs[session.kernel.name];
+        return {
+            kernelId: session.kernel.id,
+            name: spec.name,
+            language: spec.language,
+            displayName: session.name || PathExt.basename(session.path),
+            location: 'local',
+        };
+    })
+        .concat(Array.from(multiServiceManager.browser?.sessions.running() ?? [])
+        .filter(session => session.kernel && session.kernel.id !== kernelId)
+        .map(session => {
+        const spec = multiServiceManager.browser.kernelspecs.specs.kernelspecs[session.kernel.name];
+        return {
+            id: "", // TODO Assign a proper ID.
+            kernelId: session.kernel.id,
+            name: spec.name,
+            language: spec.language,
+            displayName: session.name || PathExt.basename(session.path),
+            location: 'browser',
+        };
+    }))
+        .filter(filterKernels);
+    // Add the running runtimes.
+    const listedAsSession = runningSessions.map(s => s.kernelId);
+    const runningKernels = Array.from(multiServiceManager.local.kernels.running())
+        .filter(k => !listedAsSession.includes(k.id))
+        .map(k => {
+        const spec = specs.kernelspecs[k.name];
+        return {
+            kernelId: k.id,
+            name: spec.name,
+            language: spec.language,
+            displayName: spec.display_name,
+            location: 'local',
+        };
+    })
+        .concat((multiServiceManager.remote?.runtimesManager.get() ?? [])
+        .filter(k => k.id && !listedAsSession.includes(k.id))
+        .map(runtime => {
+        const environment = multiServiceManager.remote.environments.get().find(env => env.name === runtime.environment_name);
+        return {
+            kernelId: runtime.id,
+            name: environment.name,
+            language: environment.language,
+            displayName: runtime.given_name ?? environment.title,
+            location: 'remote',
+            podName: runtime.pod_name,
+            gpu: environment.resources?.['nvidia.com/gpu'],
+        };
+    }))
+        .concat(Array.from(multiServiceManager.browser?.kernels.running() ?? [])
+        .filter(k => !listedAsSession.includes(k.id))
+        .map(k => {
+        const spec = multiServiceManager.browser.kernelspecs.specs.kernelspecs[k.name];
+        return {
+            kernelId: k.id,
+            name: spec.name,
+            language: spec.language,
+            displayName: spec.display_name,
+            location: 'browser'
+        };
+    }))
+        .filter(filterKernels);
+    runningSessions.push(...runningKernels);
+    if (runningSessions.length) {
+        const key = (variant === 'cell') ?
+            ASSIGN_EXISTING_REMOTE_RUNTIME_LABEL
+            :
+                ASSIGN_EXISTING_RUNTIME_LABEL;
+        kernels[key] = runningSessions;
+    }
+    // Environments.
+    const environments = Object.values(specs.kernelspecs)
+        .filter(spec => !!spec)
+        .map(spec => ({
+        name: spec.name,
+        language: spec.language,
+        displayName: spec.display_name,
+        gpu: spec.resources?.['nvidia.com/gpu'],
+        location: 'local',
+    }))
+        .filter(filterKernels);
+    environments.push(...(multiServiceManager.remote?.environments
+        .get()
+        .map(spec => ({
+        name: spec.name,
+        language: spec.language,
+        displayName: spec.title,
+        location: 'remote',
+        gpu: spec.resources?.['nvidia.com/gpu'],
+        burningRate: spec.burning_rate
+    }))
+        .filter(filterKernels) ?? []));
+    environments.push(...Object.values(multiServiceManager.browser?.kernelspecs.specs?.kernelspecs ?? {}).filter(spec => !!spec).map(spec => ({
+        name: spec.name,
+        language: spec.language,
+        displayName: spec.display_name,
+        location: 'browser'
+    })).filter(filterKernels));
+    if (environments.length) {
+        kernels[trans.__(ASSIGN_NEW_RUNTIME_LABEL)] = environments;
+    }
+    return kernels;
+}
+/**
+ * Get the default kernel name given a selector.
+ */
+export function getDefaultKernelName(selector) {
+    const { specs, preference } = selector;
+    const { name, language, canStart, autoStartDefault } = preference;
+    if (!specs || canStart === false) {
+        return null;
+    }
+    const defaultName = autoStartDefault ? specs.default : null;
+    if (!name && !language) {
+        return defaultName;
+    }
+    // Look for an exact match of a spec name.
+    for (const specName in specs.kernelspecs) {
+        if (specName === name) {
+            return name;
+        }
+    }
+    // Bail if there is no language.
+    if (!language) {
+        return defaultName;
+    }
+    // Check for a single kernel matching the language.
+    const matches = [];
+    for (const specName in specs.kernelspecs) {
+        const kernelLanguage = specs.kernelspecs[specName]?.language;
+        if (language === kernelLanguage) {
+            matches.push(specName);
+        }
+    }
+    if (matches.length === 1) {
+        const specName = matches[0];
+        console.warn('No exact match found for ' + specName + ', using runtime ' + specName + ' that matches ' + 'language=' + language);
+        return specName;
+    }
+    // No matches found.
+    return defaultName;
+}

package/lib/components/runtimes/RuntimeVariables.d.ts

@@ -0,0 +1,38 @@
+import { ReactElement } from 'react';
+import { ITranslator } from '@jupyterlab/translation';
+/**
+ * {@link RuntimeVariables} properties
+ */
+export interface IRuntimeVariablesProps {
+    /**
+     * Component class name
+     */
+    className?: string;
+    /**
+     * Available kernel variables
+     *
+     * Mapping (variable name, variable type)
+     */
+    kernelVariables?: {
+        [name: string]: string;
+    };
+    /**
+     * Kernel variables to be transferred.
+     */
+    selectedVariables: string[];
+    setSelectVariable: (l: string[]) => void;
+    /**
+     * Whether to transfer the variable from the current
+     * to the selected kernel or not.
+     */
+    transferVariables: boolean;
+    setTransferVariable: (v: boolean) => void;
+    /**
+     * Application translator
+     */
+    translator?: ITranslator;
+}
+/**
+ * Runtime variables selector component.
+ */
+export declare function RuntimeVariables(props: IRuntimeVariablesProps): ReactElement;

package/lib/components/runtimes/RuntimeVariables.js

@@ -0,0 +1,80 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+import { useMemo } from 'react';
+import { IconButton, ToggleSwitch, FormControl } from '@primer/react';
+import { Box } from "@datalayer/primer-addons";
+import { Blankslate, DataTable, Table } from '@primer/react/experimental';
+import { nullTranslator } from '@jupyterlab/translation';
+import { checkIcon } from '@jupyterlab/ui-components';
+/**
+ * Runtime variables selector component.
+ */
+export function RuntimeVariables(props) {
+    const { className, translator, selectedVariables, setSelectVariable, transferVariables, setTransferVariable, kernelVariables } = props;
+    const trans = useMemo(() => (translator ?? nullTranslator).load('jupyterlab'), [translator]);
+    const nRows = Object.keys(kernelVariables ?? {}).length;
+    // Sorting and actions does not play nice together :'(
+    const columns = [
+        {
+            header: trans.__('Name'),
+            field: 'name',
+            rowHeader: true
+        },
+        {
+            header: trans.__('Type'),
+            field: 'type'
+        },
+        {
+            id: 'select',
+            maxWidth: '70px',
+            header: () => (_jsx(IconButton, { "aria-label": selectedVariables.length === nRows
+                    ? trans.__('Deselect all')
+                    : trans.__('Select all'), title: selectedVariables.length === nRows
+                    ? trans.__('Deselect all')
+                    : trans.__('Select all'), icon: selectedVariables.length === nRows
+                    ? checkIcon.react
+                    : () => _jsx("span", {}), variant: "default", size: "small", onClick: e => {
+                    e.preventDefault();
+                    if (selectedVariables.length === nRows) {
+                        setSelectVariable([]);
+                    }
+                    else {
+                        setSelectVariable(Object.keys(kernelVariables ?? {}));
+                    }
+                } })),
+            renderCell: (row) => {
+                const isSelected = selectedVariables.includes(row.name);
+                return (_jsx(IconButton, { "aria-label": isSelected
+                        ? trans.__('Deselect: %1', row.name)
+                        : trans.__('Select: %1', row.name), title: isSelected
+                        ? trans.__('Deselect: %1', row.name)
+                        : trans.__('Select: %1', row.name), icon: isSelected ? checkIcon.react : () => _jsx("span", {}), variant: "default", size: "small", onClick: e => {
+                        e.preventDefault();
+                        const index = selectedVariables.findIndex(v => v === row.name);
+                        if (index >= 0) {
+                            const copy = [...selectedVariables];
+                            copy.splice(index, 1);
+                            setSelectVariable(copy);
+                        }
+                        else {
+                            setSelectVariable([...selectedVariables, row.name]);
+                        }
+                    } }));
+            }
+        }
+    ];
+    return (_jsxs(Box, { className: className, sx: { paddingTop: "10px" }, children: [_jsxs(FormControl, { layout: "horizontal", children: [_jsx(FormControl.Label, { children: trans.__('Transfer variables') }), _jsx(ToggleSwitch, { checked: transferVariables, size: "small", onClick: (e) => {
+                            e.preventDefault();
+                            setTransferVariable(!transferVariables);
+                        }, "aria-labelledby": "kernel-toggle-variables" })] }), transferVariables && (_jsxs(Table.Container, { sx: { flex: '1 1 auto', marginTop: 3 }, children: [_jsx(Table.Subtitle, { as: "p", id: "dla-kernel-variables-subtitle", children: trans.__('The list of transferable runtime variables.') }), kernelVariables ? (Object.keys(kernelVariables ?? {}).length ? (_jsx(DataTable, { "aria-labelledby": "dla-kernel-variables", "aria-describedby": "dla-kernel-variables-subtitle", data: Object.entries(kernelVariables ?? {})
+                            .map(([name, type], id) => ({ id, name, type }))
+                            .sort((a, b) => (a.name > b.name ? 1 : -1)), columns: columns, cellPadding: "condensed" })) : (_jsx(Box, { sx: { gridArea: 'table' }, children: _jsx(Blankslate, { border: true, children: _jsx(Blankslate.Heading, { children: trans.__('No eligible variables.') }) }) }))) : (_jsx(Table.Skeleton, { "aria-labelledby": "dla-kernel-variables", "aria-describedby": "dla-kernel-variables-subtitle", columns: columns, rows: 5 }))] }))] }));
+}

package/lib/components/runtimes/index.d.ts

@@ -0,0 +1,11 @@
+export * from './RuntimeCellVariables';
+export * from './RuntimeCellVariablesDialog';
+export * from './RuntimeLauncherDialog';
+export * from './RuntimePickerBase';
+export * from './RuntimePickerCell';
+export * from './RuntimePickerNotebook';
+export * from './RuntimeReservationControl';
+export * from './RuntimeSimplePicker';
+export * from './RuntimeTransfer';
+export * from './RuntimeUtils';
+export * from './RuntimeVariables';

package/lib/components/runtimes/index.js

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+export * from './RuntimeCellVariables';
+export * from './RuntimeCellVariablesDialog';
+export * from './RuntimeLauncherDialog';
+export * from './RuntimePickerBase';
+export * from './RuntimePickerCell';
+export * from './RuntimePickerNotebook';
+export * from './RuntimeReservationControl';
+export * from './RuntimeSimplePicker';
+export * from './RuntimeTransfer';
+export * from './RuntimeUtils';
+export * from './RuntimeVariables';

package/lib/components/screenshot/ScreenCapture.d.ts

@@ -0,0 +1,38 @@
+import { Component, CSSProperties } from 'react';
+type ScreenCaptureProps = {
+    children: any;
+    onStartCapture?: () => void;
+    onEndCapture: (url: string) => void;
+};
+type ScreenCaptureState = {
+    on: boolean;
+    startX: number;
+    startY: number;
+    endX: number;
+    endY: number;
+    crossHairsTop: number;
+    crossHairsLeft: number;
+    isMouseDown: boolean;
+    windowWidth: number;
+    windowHeight: number;
+    borderWidth: number | string | CSSProperties;
+    cropPositionTop: number;
+    cropPositionLeft: number;
+    cropWidth: number;
+    cropHeigth: number;
+    imageURL: string;
+};
+export declare class ScreenCapture extends Component<ScreenCaptureProps, ScreenCaptureState> {
+    state: ScreenCaptureState;
+    handleWindowResize: () => void;
+    componentDidMount: () => void;
+    componentWillUnmount: () => void;
+    handStartCapture: () => void;
+    handleMouseMove: (e: any) => void;
+    handleMouseDown: (e: any) => void;
+    handleMouseUp: () => void;
+    handleClickTakeScreenShot: () => void;
+    renderChild: () => any;
+    render(): any;
+}
+export default ScreenCapture;

package/lib/components/screenshot/ScreenCapture.js

@@ -0,0 +1,179 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+import { Component } from 'react';
+import html2canvas from 'html2canvas';
+export class ScreenCapture extends Component {
+    state = {
+        on: false,
+        startX: 0,
+        startY: 0,
+        endX: 0,
+        endY: 0,
+        crossHairsTop: 0,
+        crossHairsLeft: 0,
+        isMouseDown: false,
+        windowWidth: 0,
+        windowHeight: 0,
+        borderWidth: 0,
+        cropPositionTop: 0,
+        cropPositionLeft: 0,
+        cropWidth: 0,
+        cropHeigth: 0,
+        imageURL: '',
+    };
+    handleWindowResize = () => {
+        const windowWidth = window.innerWidth ||
+            document.documentElement.clientWidth ||
+            document.body.clientWidth;
+        const windowHeight = window.innerHeight ||
+            document.documentElement.clientHeight ||
+            document.body.clientHeight;
+        this.setState({
+            windowWidth,
+            windowHeight,
+        });
+    };
+    componentDidMount = () => {
+        this.handleWindowResize();
+        window.addEventListener('resize', this.handleWindowResize);
+    };
+    componentWillUnmount = () => {
+        window.removeEventListener('resize', this.handleWindowResize);
+    };
+    handStartCapture = () => this.setState({ on: true });
+    handleMouseMove = (e) => {
+        const { isMouseDown, windowWidth, windowHeight, startX, startY, borderWidth } = this.state;
+        let cropPositionTop = startY;
+        let cropPositionLeft = startX;
+        const endX = e.clientX;
+        const endY = e.clientY;
+        const isStartTop = endY >= startY;
+        const isStartBottom = endY <= startY;
+        const isStartLeft = endX >= startX;
+        const isStartRight = endX <= startX;
+        const isStartTopLeft = isStartTop && isStartLeft;
+        const isStartTopRight = isStartTop && isStartRight;
+        const isStartBottomLeft = isStartBottom && isStartLeft;
+        const isStartBottomRight = isStartBottom && isStartRight;
+        let newBorderWidth = borderWidth;
+        let cropWidth = 0;
+        let cropHeigth = 0;
+        if (isMouseDown) {
+            if (isStartTopLeft) {
+                newBorderWidth = `${startY}px ${windowWidth - endX}px ${windowHeight -
+                    endY}px ${startX}px`;
+                cropWidth = endX - startX;
+                cropHeigth = endY - startY;
+            }
+            if (isStartTopRight) {
+                newBorderWidth = `${startY}px ${windowWidth - startX}px ${windowHeight -
+                    endY}px ${endX}px`;
+                cropWidth = startX - endX;
+                cropHeigth = endY - startY;
+                cropPositionLeft = endX;
+            }
+            if (isStartBottomLeft) {
+                newBorderWidth = `${endY}px ${windowWidth - endX}px ${windowHeight -
+                    startY}px ${startX}px`;
+                cropWidth = endX - startX;
+                cropHeigth = startY - endY;
+                cropPositionTop = endY;
+            }
+            if (isStartBottomRight) {
+                newBorderWidth = `${endY}px ${windowWidth - startX}px ${windowHeight -
+                    startY}px ${endX}px`;
+                cropWidth = startX - endX;
+                cropHeigth = startY - endY;
+                cropPositionLeft = endX;
+                cropPositionTop = endY;
+            }
+        }
+        cropWidth *= window.devicePixelRatio;
+        cropHeigth *= window.devicePixelRatio;
+        this.setState({
+            crossHairsTop: e.clientY,
+            crossHairsLeft: e.clientX,
+            borderWidth: newBorderWidth,
+            cropWidth,
+            cropHeigth,
+            cropPositionTop: cropPositionTop,
+            cropPositionLeft: cropPositionLeft,
+        });
+    };
+    handleMouseDown = (e) => {
+        const startX = e.clientX;
+        const startY = e.clientY;
+        this.setState(prevState => ({
+            startX,
+            startY,
+            cropPositionTop: startY,
+            cropPositionLeft: startX,
+            isMouseDown: true,
+            borderWidth: `${prevState.windowWidth}px ${prevState.windowHeight}px`,
+        }));
+    };
+    handleMouseUp = () => {
+        this.handleClickTakeScreenShot();
+        this.setState({
+            on: false,
+            isMouseDown: false,
+            borderWidth: 0,
+        });
+    };
+    handleClickTakeScreenShot = () => {
+        const { windowWidth, windowHeight, cropPositionTop, cropPositionLeft, cropWidth, cropHeigth, } = this.state;
+        const body = document.querySelector('body');
+        if (body) {
+            let scale = window.devicePixelRatio;
+            html2canvas(body, {
+                width: windowWidth,
+                height: windowHeight,
+                scale: scale
+            }).then(canvas => {
+                const croppedCanvas = document.createElement('canvas');
+                const croppedCanvasContext = croppedCanvas.getContext('2d');
+                croppedCanvas.width = cropWidth;
+                croppedCanvas.height = cropHeigth;
+                if (croppedCanvasContext) {
+                    croppedCanvasContext.drawImage(canvas, cropPositionLeft * scale, cropPositionTop * scale, cropWidth * scale, cropHeigth * scale, 0, 0, cropWidth * scale, cropHeigth * scale);
+                }
+                if (croppedCanvas) {
+                    const type = 'image/png';
+                    const quality = 1;
+                    const outputshotData = croppedCanvas.toDataURL(type, quality);
+                    this.props.onEndCapture(outputshotData);
+                }
+            });
+        }
+        this.setState({
+            crossHairsTop: 0,
+            crossHairsLeft: 0,
+        });
+    };
+    renderChild = () => {
+        const { children } = this.props;
+        const props = {
+            onStartCapture: this.handStartCapture
+        };
+        if (typeof children === 'function') {
+            return children(props);
+        }
+        return children;
+    };
+    render() {
+        const { on, crossHairsTop, crossHairsLeft, borderWidth, isMouseDown, } = this.state;
+        if (!on) {
+            return this.renderChild();
+        }
+        return (_jsxs("div", { onMouseMove: this.handleMouseMove, onMouseDown: this.handleMouseDown, onMouseUp: this.handleMouseUp, children: [this.renderChild(), _jsx("div", { className: `overlay ${isMouseDown && 'highlighting'}`, style: { borderWidth: `${borderWidth}` } }), _jsx("div", { className: 'crosshairs', style: { left: crossHairsLeft + 'px', top: crossHairsTop + 'px' } })] }));
+    }
+}
+export default ScreenCapture;

package/lib/components/screenshot/ScreenCaptureButton.d.ts

@@ -0,0 +1,3 @@
+import { PropsWithChildren } from "react";
+export declare const ScreenCaptureButton: (props: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+export default ScreenCaptureButton;

package/lib/components/screenshot/ScreenCaptureButton.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Link, Tooltip, Button } from "@primer/react";
+import { ScreenFullIcon } from "@primer/octicons-react";
+import { lazyWithPreload, WithSuspense } from "../../utils";
+import { useToast } from "../../hooks";
+import { useLayoutStore } from "../../state";
+const ScreenCapture = WithSuspense(lazyWithPreload(() => import("../screenshot/ScreenCapture")));
+export const ScreenCaptureButton = (props) => {
+    const { enqueueToast } = useToast();
+    const { setScreenCapture, hideScreenshot } = useLayoutStore();
+    const handleScreenCapture = (screenCapture) => {
+        setScreenCapture(screenCapture);
+        hideScreenshot();
+        enqueueToast('Screen is captured.', { variant: 'success' });
+    };
+    return (_jsx(ScreenCapture, { onEndCapture: handleScreenCapture, children: ({ onStartCapture }) => (_jsx(Tooltip, { text: "Take a screen capture", direction: "s", children: _jsx(Button, { variant: "invisible", children: _jsx(Link, { href: "javascript: return false;", sx: {
+                        color: 'fg.muted',
+                        ':hover, :focus, &[aria-expanded=true]': { background: 'none !important', color: 'accent.fg' }
+                    }, onClick: e => { e.preventDefault(); onStartCapture(); }, children: _jsx(ScreenFullIcon, {}) }) }) })) }));
+};
+export default ScreenCaptureButton;

package/lib/components/screenshot/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ScreenCapture';
+export * from './ScreenCaptureButton';

package/lib/components/screenshot/index.js

@@ -0,0 +1,11 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+export * from './ScreenCapture';
+export * from './ScreenCaptureButton';

package/lib/components/snapshots/RuntimeSnapshotMenu.d.ts

@@ -0,0 +1,36 @@
+import { type PropsWithChildren } from 'react';
+import { Kernel } from '@jupyterlab/services';
+import { IMultiServiceManager } from '../../api';
+/**
+ * Runtime snapshot menu component properties
+ */
+type IRuntimeSnapshotMenu = {
+    /**
+     * Application multi service manager.
+     */
+    multiServiceManager?: IMultiServiceManager;
+    /**
+     * Connection to the current kernel.
+     *
+     * It is needed only for browser kernels.
+     */
+    connection?: Kernel.IKernelConnection;
+    /**
+     * Pod name
+     *
+     * It is needed for remote kernels.
+     */
+    podName?: string;
+    /**
+     * Whether the menu is disabled.
+     */
+    disabled: boolean;
+};
+/**
+ * Runtime Snapshot menu component.
+ */
+export declare function RuntimeSnapshotMenu(props: PropsWithChildren<IRuntimeSnapshotMenu>): JSX.Element;
+export declare namespace RuntimeSnapshotMenu {
+    var defaultProps: Partial<IRuntimeSnapshotMenu>;
+}
+export {};