@datalayer/core 0.0.1 → 0.0.3

package/lib/components/text-reveal/TextRevealAnimation.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { BaseProps } from '../primer';
+export type TextRevealAnimationProps = BaseProps<HTMLSpanElement> & Omit<React.HTMLAttributes<HTMLSpanElement>, 'children'> & {
+    children: React.ReactChild;
+};
+export declare function TextRevealAnimation({ children, ...rest }: TextRevealAnimationProps): import("react/jsx-runtime").JSX.Element | null;

package/lib/components/text-reveal/TextRevealAnimation.js

@@ -0,0 +1,49 @@
+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.
+ */
+import React, { useEffect } from 'react';
+import clsx from 'clsx';
+import { useTextRevealAnimationLines } from './useTextRevealAnimationLines';
+import styles from './TextRevealAnimation.module.css';
+export function TextRevealAnimation({ children, ...rest }) {
+    const [animationStarted, setAnimationStarted] = React.useState(false);
+    const [hasAnimationCompleted, setHasAnimationCompleted] = React.useState(false);
+    const { ref, lines } = useTextRevealAnimationLines(children.toString() || '');
+    const onLineAnimationEnd = (i) => {
+        if (lines && i === lines.length - 1) {
+            setHasAnimationCompleted(true);
+        }
+    };
+    useEffect(() => {
+        const el = ref.current;
+        const observer = new IntersectionObserver(entries => {
+            for (const entry of entries) {
+                if (entry.isIntersecting) {
+                    setAnimationStarted(true);
+                    if (el) {
+                        observer.unobserve(el);
+                    }
+                }
+            }
+        }, {
+            threshold: 1,
+            rootMargin: '0px 0px -10% 0px',
+        });
+        if (el) {
+            observer.observe(el);
+        }
+        return () => {
+            if (el) {
+                observer.unobserve(el);
+            }
+        };
+    }, [ref]);
+    if (typeof children !== 'string' && (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test')) {
+        console.warn('Children passed to TextRevealAnimation must be a string');
+        return null;
+    }
+    return (_jsx("span", { ref: ref, ...rest, children: lines?.map((line, i) => (_jsxs(React.Fragment, { children: [_jsx("span", { className: clsx(styles.TextRevealAnimation, animationStarted && styles['TextRevealAnimation--visible'], animationStarted &&
+                        (hasAnimationCompleted ? styles['TextRevealAnimation'] : styles['TextRevealAnimation--animated'])), style: { '--animation-delay': `${220 + i * 200}ms` }, onAnimationEnd: () => onLineAnimationEnd(i), children: line }), ' '] }, line))) }));
+}

package/lib/components/text-reveal/TextRevealAnimation.module.css

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+
+@keyframes wipe {
+  from {
+    transform: scaleX(1);
+  }
+  to {
+    transform: scaleX(0);
+  }
+}
+
+.TextRevealAnimation {
+  opacity: 0;
+  transition: opacity var(--brand-animation-duration-default) var(--brand-animation-easing-default);
+}
+
+.TextRevealAnimation--visible {
+  opacity: 1;
+}
+
+.TextRevealAnimation,
+.TextRevealAnimation--animated {
+  width: 100%;
+  min-height: 1lh;
+  position: relative;
+}
+
+.TextRevealAnimation--animated::after {
+  content: '';
+  display: inline;
+  position: absolute;
+  top: 0;
+  right: 0;
+  width: 100%;
+  height: 100%;
+  background-color: var(--brand-color-accent-primary);
+  transform-origin: right;
+  animation: wipe var(--brand-animation-duration-extended) forwards var(--brand-animation-easing-default);
+  animation-delay: var(--animation-delay);
+}

package/lib/components/text-reveal/index.d.ts

@@ -0,0 +1 @@
+export * from './TextRevealAnimation';

package/lib/components/text-reveal/index.js

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

package/lib/components/text-reveal/useTextRevealAnimationLines.d.ts

@@ -0,0 +1,4 @@
+export declare const useTextRevealAnimationLines: (text?: string) => {
+    ref: import("react").RefObject<HTMLElement>;
+    lines: string[] | undefined;
+};

package/lib/components/text-reveal/useTextRevealAnimationLines.js

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { useRef, useEffect, useState } from 'react';
+export const useTextRevealAnimationLines = (text) => {
+    const ref = useRef(null);
+    const [lines, setLines] = useState();
+    useEffect(() => {
+        if (!ref.current || !text)
+            return;
+        const wrapLines = () => {
+            const element = ref.current;
+            if (!element || !text)
+                return;
+            const originalColor = window.getComputedStyle(element).color;
+            element.style.color = 'transparent';
+            element.textContent = '';
+            const words = text.split(' ');
+            const lineBreakPositions = [];
+            let prevHeight = 0;
+            const linesArr = [];
+            for (const word of words) {
+                element.textContent += `${word} `;
+                const height = element.offsetHeight;
+                if (linesArr.length === 0) {
+                    prevHeight = height;
+                    linesArr.push([word]);
+                    continue;
+                }
+                if (height > prevHeight) {
+                    lineBreakPositions.push(linesArr.length);
+                    linesArr.push([word]);
+                }
+                else {
+                    linesArr.at(-1)?.push(word);
+                }
+                prevHeight = height;
+            }
+            element.style.color = originalColor;
+            element.textContent = '';
+            setLines(linesArr.map(line => line.join(' ')));
+        };
+        wrapLines();
+    }, [text]);
+    return { ref, lines };
+};

package/lib/components/tokens/SpaceVariantToken.d.ts

@@ -0,0 +1,5 @@
+import { ISpaceVariant } from "../../models";
+export declare const SpaceVariantToken: (props: {
+    variant: ISpaceVariant;
+}) => import("react/jsx-runtime").JSX.Element;
+export default SpaceVariantToken;

package/lib/components/tokens/SpaceVariantToken.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { Token } from "@primer/react";
+import { ProjectIcon } from "@primer/octicons-react";
+import { StudentIcon } from "@datalayer/icons-react";
+export const SpaceVariantToken = (props) => {
+    const { variant } = props;
+    switch (variant) {
+        case ("default"):
+            return _jsx(Token, { text: "default", leadingVisual: ProjectIcon });
+        case ("course"):
+            return _jsx(Token, { text: "course", leadingVisual: StudentIcon });
+        default:
+            return _jsx(_Fragment, {});
+    }
+};
+export default SpaceVariantToken;

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

@@ -0,0 +1 @@
+export * from './SpaceVariantToken';

package/lib/components/tokens/index.js

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

package/lib/components/toolbars/AssignmentEditorToolbar.d.ts

@@ -0,0 +1,4 @@
+export declare const AssignmentEditorToolbar: (props: {
+    notebookId: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export default AssignmentEditorToolbar;

package/lib/components/toolbars/AssignmentEditorToolbar.js

@@ -0,0 +1,18 @@
+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.
+ */
+import { Button, Box } from '@primer/react';
+import { RepoPushIcon, PlayIcon, StopIcon } from '@primer/octicons-react';
+import { notebookStore } from '@datalayer/jupyter-react';
+import { useGradeStore } from '../../state';
+export const AssignmentEditorToolbar = (props) => {
+    const { notebookId } = props;
+    const { grade } = useGradeStore();
+    const notebook = notebookStore.getState().selectNotebook(notebookId);
+    return (_jsxs(Box, { display: "flex", children: [_jsx(Box, { children: _jsx(Button, { variant: "invisible", size: "small", leadingVisual: RepoPushIcon, onClick: () => grade(new Date()), children: "Grade" }) }), notebook?.kernelStatus !== 'busy' &&
+                _jsx(Box, { children: _jsx(Button, { variant: "invisible", size: "small", leadingVisual: PlayIcon, onClick: e => notebookStore.getState().runAll(notebookId), children: "Run all" }) }), notebook?.kernelStatus === 'busy' &&
+                _jsx(Box, { children: _jsx(Button, { variant: "danger", size: "small", leadingVisual: StopIcon, onClick: e => notebookStore.getState().interrupt(notebookId), children: "Interrupt" }) })] }));
+};
+export default AssignmentEditorToolbar;

package/lib/components/toolbars/DocumentEditorToolbar.d.ts

@@ -0,0 +1,2 @@
+export declare const DocumentEditorToolbar: () => import("react/jsx-runtime").JSX.Element;
+export default DocumentEditorToolbar;

package/lib/components/toolbars/DocumentEditorToolbar.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { Button, Box } from '@primer/react';
+import { RepoPushIcon } from '@primer/octicons-react';
+import { documentStore } from '../../state';
+export const DocumentEditorToolbar = () => {
+    return (_jsx(Box, { display: "flex", children: _jsx(Box, { children: _jsx(Button, { variant: "invisible", size: "small", leadingVisual: RepoPushIcon, onClick: () => documentStore.getState().save(new Date()), children: "Save" }) }) }));
+};
+export default DocumentEditorToolbar;

package/lib/components/toolbars/NotebookEditorToolbar.d.ts

@@ -0,0 +1,29 @@
+import { Session } from '@jupyterlab/services';
+import { CommandRegistry } from '@lumino/commands';
+import type { IRuntimeDesc } from '../../models';
+/**
+ * NotebookEditorToolbar component properties
+ */
+export type INotebookEditorToolbar = {
+    /**
+     * Jupyter commands registry
+     */
+    commandRegistry?: CommandRegistry;
+    /**
+     * Kernel description
+     */
+    runtimeDesc?: IRuntimeDesc;
+    /**
+     * Callback to save the notebook model
+     */
+    save: () => void;
+    /**
+     * Session connection
+     */
+    sessionConnection?: Session.ISessionConnection;
+};
+/**
+ * Notebook editor toolbar
+ */
+export declare function NotebookEditorToolbar(props: INotebookEditorToolbar): JSX.Element;
+export default NotebookEditorToolbar;

package/lib/components/toolbars/NotebookEditorToolbar.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { NotebookCommandIds } from '@datalayer/jupyter-react';
+import { Button } from '@primer/react';
+import { PlayIcon, StopIcon } from '@primer/octicons-react';
+import { useEffect, useState } from 'react';
+/**
+ * Notebook editor toolbar
+ */
+export function NotebookEditorToolbar(props) {
+    const { commandRegistry, runtimeDesc, sessionConnection } = props;
+    const [kernelStatus, setKernelStatus] = useState();
+    useEffect(() => {
+        const onStatusChanged = () => {
+            setKernelStatus(sessionConnection?.kernel?.status);
+        };
+        onStatusChanged();
+        sessionConnection?.statusChanged.connect(onStatusChanged);
+        sessionConnection?.connectionStatusChanged.connect(onStatusChanged);
+        return () => {
+            sessionConnection?.statusChanged.disconnect(onStatusChanged);
+            sessionConnection?.connectionStatusChanged.disconnect(onStatusChanged);
+        };
+    }, [sessionConnection]);
+    return (_jsxs(_Fragment, { children: [_jsx(Button, { variant: "invisible", size: "small", leadingVisual: PlayIcon, disabled: !runtimeDesc?.location || kernelStatus === 'busy', onClick: (e) => commandRegistry?.execute(NotebookCommandIds.runAll), children: "Run all" }), _jsx(Button, { variant: "invisible", size: "small", leadingVisual: StopIcon, disabled: !runtimeDesc?.location || kernelStatus !== 'busy', onClick: (e) => commandRegistry?.execute(NotebookCommandIds.interrupt), children: "Interrupt" })] }));
+}
+export default NotebookEditorToolbar;

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

@@ -0,0 +1,3 @@
+export * from './AssignmentEditorToolbar';
+export * from './DocumentEditorToolbar';
+export * from './NotebookEditorToolbar';

package/lib/components/toolbars/index.js

@@ -0,0 +1,7 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export * from './AssignmentEditorToolbar';
+export * from './DocumentEditorToolbar';
+export * from './NotebookEditorToolbar';

package/lib/components/users/PeerIndicator.d.ts

@@ -0,0 +1,18 @@
+import type { Awareness } from 'y-protocols/awareness';
+/**
+ * PeersIndicator properties
+ */
+export type IPeersIndicatorProps = {
+    /**
+     * Document awareness
+     */
+    awareness: Awareness;
+    /**
+     * Current user handle
+     */
+    currentUserHandle: string;
+};
+/**
+ * Connected peers indicator
+ */
+export declare function PeersIndicator({ awareness, currentUserHandle }: IPeersIndicatorProps): JSX.Element | null;

package/lib/components/users/PeerIndicator.js

@@ -0,0 +1,100 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { useEffect, useState } from 'react';
+import { Avatar, AvatarStack } from '@primer/react';
+import { getAvatarURL, getRelativeTime } from '../../utils';
+const AVATAR_SIZE = 28;
+const SPACER_USER_AGENT = 'DatalayerSpacer';
+const AWARENESS_NOTIFICATION_TIMEOUT_MS = 30_000;
+var NotificationType;
+(function (NotificationType) {
+    NotificationType["PROGRESS"] = "var(--borderColor-accent-emphasis)";
+    NotificationType["ERROR"] = "var(--borderColor-danger-emphasis)";
+    NotificationType["SUCCESS"] = "var(--borderColor-success-emphasis)";
+})(NotificationType || (NotificationType = {}));
+const MSG_TO_NOTIFICATION = {
+    '-1': NotificationType.ERROR,
+    '0': NotificationType.PROGRESS,
+    '1': NotificationType.SUCCESS
+};
+function isExpired(timestamp) {
+    // Timestamp is expired if older than 10 seconds ago
+    return timestamp + AWARENESS_NOTIFICATION_TIMEOUT_MS < Date.now();
+}
+function defaultAvatarSrc(color, text) {
+    const svg = `<svg width="24" height="24" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><circle cx="12" cy="12" r="12" fill="${color}" stroke="none" /><text x="12" y="12" fill="black">${text}</text></svg>`;
+    return 'data:image/svg+xml;charset=utf-8,' + encodeURIComponent(svg);
+}
+/**
+ * Connected peers indicator
+ */
+export function PeersIndicator({ awareness, currentUserHandle }) {
+    const [peers, setPeers] = useState([]);
+    useEffect(() => {
+        const onAwarenessChange = () => {
+            const peers = awareness.getStates();
+            setPeers(Array.from(peers.values())
+                .filter(p => p.user &&
+                p.user?.name !== currentUserHandle &&
+                !(p.user?.agent ?? '').startsWith(SPACER_USER_AGENT))
+                .reduce((agg, peer) => {
+                const user = peer.user;
+                const notExpiredNotification = !isExpired(peer.notification?.timestamp ?? 0);
+                const newPeer = user.agent
+                    ? {
+                        // TODO pick something better
+                        avatarUrl: 'https://static.vecteezy.com/system/resources/previews/006/662/139/large_2x/artificial-intelligence-ai-processor-chip-icon-symbol-for-graphic-design-logo-web-site-social-media-mobile-app-ui-illustration-free-vector.jpg',
+                        color: user.color,
+                        displayName: user.agent,
+                        handle: 'agent',
+                        initials: 'AI',
+                        username: user.agent,
+                        notification: notExpiredNotification
+                            ? `${peer.notification?.message} ${getRelativeTime(new Date(peer.notification.timestamp))}`
+                            : undefined,
+                        notificationType: notExpiredNotification &&
+                            peer.notification?.message_type !== undefined
+                            ? MSG_TO_NOTIFICATION[peer.notification?.message_type.toString()]
+                            : undefined
+                    }
+                    : {
+                        avatarUrl: user.avatar_url,
+                        color: user.color,
+                        displayName: user.display_name,
+                        handle: user.name,
+                        initials: user.initials,
+                        username: user.username
+                    };
+                // Ensure to display a peer only once
+                if (!agg.map(p => p.username).includes(newPeer.username)) {
+                    agg.push(newPeer);
+                }
+                return agg;
+            }, []));
+        };
+        onAwarenessChange();
+        awareness.on('change', onAwarenessChange);
+        // Force regular update to update agent notification
+        const updateInterval = setInterval(onAwarenessChange, AWARENESS_NOTIFICATION_TIMEOUT_MS / 3);
+        return () => {
+            clearInterval(updateInterval);
+            awareness.off('change', onAwarenessChange);
+        };
+    }, [awareness, currentUserHandle]);
+    return (_jsx(AvatarStack, { children: peers.map(peer => {
+            let title = `${peer.displayName}\n${peer.handle}`;
+            if (peer.notification) {
+                title += `\n${peer.notification}`;
+            }
+            return (_jsx(Avatar, { sx: {
+                    border: peer.notificationType
+                        ? `var(--borderWidth-thick) solid ${peer.notificationType}`
+                        : 'none'
+                }, title: title, src: peer.avatarUrl
+                    ? getAvatarURL(peer.avatarUrl)
+                    : defaultAvatarSrc(peer.color, peer.initials), size: AVATAR_SIZE }, peer.displayName));
+        }) }));
+}

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

@@ -0,0 +1 @@
+export * from './PeerIndicator';

package/lib/components/users/index.js

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

package/lib/config/Configuration.d.ts

@@ -0,0 +1,111 @@
+import { ISignal } from '@lumino/signaling';
+export declare const FORCE_ACTIVATE_RUNTIMES_PLUGINS = false;
+export type IDatalayerCoreConfig = {
+    /**
+     * Use mock model, useful for e.g. storybooks.
+     */
+    useMock: boolean;
+    /**
+     * Does the webapp need a jupyter server.
+     */
+    jupyterServerless: boolean;
+    /**
+     * IAM API URL.
+     */
+    iamRunUrl: string;
+    /**
+     * Runtimes API URL.
+     */
+    runtimesRunUrl: string;
+    /**
+     * Spacer API URL.
+     */
+    spacerRunUrl: string;
+    /**
+     * Library API URL.
+     */
+    libraryRunUrl: string;
+    /**
+     * AI Agents API URL.
+     */
+    aiagentsRunUrl: string;
+    /**
+     * Growth API URL.
+     */
+    growthRunUrl: string;
+    /**
+     * Inbounds API URL.
+     */
+    inboundsRunUrl: string;
+    /**
+     * Success API URL.
+     */
+    successRunUrl: string;
+    /**
+     * Support API URL.
+     */
+    supportRunUrl: string;
+    /**
+     * Load configuration from server.
+     */
+    loadConfigurationFromServer: boolean;
+    /**
+     * Launcher card customization.
+     */
+    launcher: {
+        /**
+         * Card category.
+         */
+        category: string;
+        /**
+         * Card name.
+         */
+        name: string;
+        /**
+         * Card icon SVG URL.
+         */
+        icon: string | null;
+        /**
+         * Card rank.
+         */
+        rank: number;
+    };
+    /**
+     * Brand customization.
+     */
+    brand: {
+        name: string;
+        logoUrl: string;
+        logoSquareUrl: string;
+        about: string;
+        copyright: string;
+        docsUrl: string;
+        supportUrl: string;
+        pricingUrl: string;
+        termsUrl: string;
+        privacyUrl: string;
+    };
+    /**
+     * Whether to display the white labelled user interface or not.
+     */
+    whiteLabel: boolean;
+};
+export interface IRuntimesConfiguration {
+    /**
+     * Maximal number of notebook remote runtimes per user.
+     */
+    maxNotebookRuntimes: number;
+    /**
+     * Maximal number of cell remote runtimes per user.
+     */
+    maxCellRuntimes: number;
+}
+export declare class DatalayerConfiguration {
+    private _configuration;
+    private _configurationChanged;
+    constructor();
+    set configuration(configuration: IDatalayerCoreConfig);
+    get configuration(): IDatalayerCoreConfig;
+    get configurationChanged(): ISignal<DatalayerConfiguration, IDatalayerCoreConfig>;
+}
+export default DatalayerConfiguration;

package/lib/config/Configuration.js

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { Signal } from '@lumino/signaling';
+import { coreStore } from '../state';
+export const FORCE_ACTIVATE_RUNTIMES_PLUGINS = false;
+export class DatalayerConfiguration {
+    _configuration = coreStore.getState().configuration;
+    _configurationChanged;
+    constructor() {
+        this._configurationChanged = new Signal(this);
+    }
+    set configuration(configuration) {
+        this._configuration = configuration;
+        this._configurationChanged.emit(configuration);
+    }
+    get configuration() {
+        return this._configuration;
+    }
+    get configurationChanged() {
+        return this._configurationChanged;
+    }
+}
+export default DatalayerConfiguration;

package/lib/config/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Configuration';
+export * from './integrations';

package/lib/config/index.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export * from './Configuration';
+export * from './integrations';

package/lib/config/integrations/Loom.d.ts

@@ -0,0 +1 @@
+export declare const getLoomPublicAppId: () => string;

package/lib/config/integrations/Loom.js

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+const IS_LOCALHOST = location.hostname === 'localhost';
+export const getLoomPublicAppId = () => {
+    return IS_LOCALHOST
+        ? LOOM_PUBLIC_APP_ID.LOCALHOST
+        : LOOM_PUBLIC_APP_ID.DATALAYER_IO;
+};
+// It is safe to expose PUBLIC APP ID here.
+// @see https://dev.loom.com/docs
+const LOOM_PUBLIC_APP_ID = {
+    LOCALHOST: "05754d5d-4778-4e6f-852a-a22fa0b5e87f",
+    DATALAYER_IO: "4b431848-adf7-457e-a545-0b0c7d21602a"
+};

package/lib/config/integrations/index.d.ts

@@ -0,0 +1 @@
+export * from './Loom';

package/lib/config/integrations/index.js

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

package/lib/examples/CellExample.d.ts

@@ -0,0 +1,6 @@
+import { Kernel } from '@datalayer/jupyter-react';
+type ICellExampleProps = {
+    kernel: Kernel;
+};
+export declare const CellExample: (props: ICellExampleProps) => import("react/jsx-runtime").JSX.Element;
+export default CellExample;