@datalayer/core 1.1.59 → 1.1.66

package/lib/components/buttons/LongActionButton.js

@@ -1,8 +1,4 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
 import { useCallback, useState } from 'react';
 import { IconButton, Spinner } from '@primer/react';
 /**

package/lib/components/buttons/UploadButton.d.ts

@@ -1,3 +1,4 @@
+import type { JSX } from 'react';
 import type { VariantType } from './VariantType';
 interface IUploadBaseButtonProps {
     /**

package/lib/components/buttons/UploadButton.js

@@ -1,8 +1,4 @@
 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 { useCallback, useMemo, useRef } from 'react';
 import { Button, IconButton } from '@primer/react';
 import { UploadIcon } from '@primer/octicons-react';

package/lib/components/checkout/StripeCheckout.d.ts

@@ -50,4 +50,4 @@ export type StripeCheckoutProps = {
 /**
  * Stripe checkout.
  */
-export declare function StripeCheckout({ checkoutPortal, appearance, accountUid, showStatusUsageSummary, onCheckoutSuccess, }: StripeCheckoutProps): import("react/jsx-runtime").JSX.Element;
+export declare function StripeCheckout({ checkoutPortal, appearance, accountUid, showStatusUsageSummary, onCheckoutSuccess, }: StripeCheckoutProps): import("react").JSX.Element;

package/lib/components/collaboration/LiveEditorCollaborators.d.ts

@@ -1,3 +1,23 @@
+/**
+ * The faces on a shared document: who is here now, and who belongs here.
+ *
+ * One avatar stack for every surface that names collaborators — the cards of
+ * the home page, the headers of the notebook and document editors, in the
+ * web application and in JupyterLab alike. Two sources feed it, both
+ * optional and freely combined:
+ *
+ * - `awareness`: the presence channel of a collaborative editor. The stack
+ *   follows it live — people appear as they join and leave as they go.
+ * - `collaborators`: what is known without a room, the owner and the granted
+ *   of an item. They fill the stack when there is no presence, and complete
+ *   it when there is.
+ *
+ * Every face uses the shared principal avatar rules: a selected icon wins,
+ * then a connected-account picture, then the standard personal fallback.
+ *
+ * @module components/collaboration/LiveEditorCollaborators
+ */
+import type { JSX } from 'react';
 export type LiveCollaborator = {
     /** Stable identity — a user uid, or the awareness client id. */
     id: string;
@@ -6,6 +26,10 @@ export type LiveCollaborator = {
     avatarIcon?: string;
     /** Cursor color of the presence, worn by the initials disc. */
     color?: string;
+    /** The platform uid, when the face is a real account — for its profile. */
+    uid?: string;
+    /** The account handle, when known — the address of the profile page. */
+    handle?: string;
 };
 /**
  * The slice of a Yjs-style awareness this component reads. Structural, so
@@ -26,6 +50,13 @@ export type LiveEditorCollaboratorsProps = {
     size?: number;
     /** How many faces at most; the stack keeps the first ones. */
     max?: number;
+    /**
+     * Show a face's profile some other way than through the router of this
+     * subtree — for the editors embedded under a router of their own, which hand
+     * the route to the view that has the routes. See
+     * {@link PrincipalDetailsOverlayProps.onNavigate}.
+     */
+    onNavigate?: (path: string) => void;
 };
 export declare function LiveEditorCollaborators(props: LiveEditorCollaboratorsProps): JSX.Element | null;
 export default LiveEditorCollaborators;

package/lib/components/collaboration/LiveEditorCollaborators.js

@@ -1,54 +1,68 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
-/*
- * Copyright (c) 2023-2026 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
-/**
- * The faces on a shared document: who is here now, and who belongs here.
- *
- * One avatar stack for every surface that names collaborators — the cards of
- * the home page, the headers of the notebook and document editors, in the
- * web application and in JupyterLab alike. Two sources feed it, both
- * optional and freely combined:
- *
- * - `awareness`: the presence channel of a collaborative editor. The stack
- *   follows it live — people appear as they join and leave as they go.
- * - `collaborators`: what is known without a room, the owner and the granted
- *   of an item. They fill the stack when there is no presence, and complete
- *   it when there is.
- *
- * Every face uses the shared principal avatar rules: a selected icon wins,
- * then a connected-account picture, then the standard personal fallback.
- *
- * @module components/collaboration/LiveEditorCollaborators
- */
 import { useEffect, useMemo, useState } from 'react';
 import { AvatarStack } from '@primer/react';
 import { PrincipalAvatar } from '../principal/PrincipalAvatar.js';
+import { PrincipalHoverCard } from '../principal/PrincipalHoverCard.js';
 /** The `user` field of an awareness state, in its several spellings. */
 function collaboratorOfState(clientId, state) {
     const user = state?.user;
     if (!user) {
         return undefined;
     }
+    // Not a person: the presence of the collaboration service itself — the
+    // spacer joins its own rooms, wearing an `agent` field.
+    if (user.agent) {
+        return undefined;
+    }
     const name = user.display_name || user.displayName || user.name || user.username || '';
     if (!name) {
         return undefined;
     }
+    // Nobody either: the seed identity of a Jupyter Server that does not
+    // authenticate its users — "Anonymous Hegemone" and kin. A face for it
+    // would be one avatar too many, wearing the default fallback, next to the
+    // real identity written over it a moment later.
+    if (user.anonymous === true || /^anonymous(\s|$)/i.test(name)) {
+        return undefined;
+    }
+    const uid = user.uid ?? user.id ?? undefined;
+    // The room writes the uid into `username` as often as it writes a handle;
+    // only take it for the handle when it is not just the uid under another
+    // name, or the profile link would carry a uid where a handle belongs.
+    const username = user.username && String(user.username) !== String(uid ?? '')
+        ? user.username
+        : undefined;
     return {
-        id: String(user.uid ?? user.id ?? user.username ?? clientId),
+        id: String(uid ?? user.username ?? clientId),
         name,
         avatarUrl: user.avatar_url || user.avatarUrl || undefined,
         avatarIcon: user.avatar_icon_s || user.avatarIcon || undefined,
-        color: user.color || undefined
+        color: user.color || undefined,
+        uid: uid ? String(uid) : undefined,
+        handle: user.handle || username || undefined,
+    };
+}
+/**
+ * Fold a second sighting of a person into the first, keeping the fuller of
+ * the two. The name that wins is the one belonging to the record that also
+ * carries a uid — the identity a profile is named by, "Eric Charles" over
+ * the room's cursor label "eric" — and every other field is taken wherever it
+ * is present. The cursor color of the live presence, seen first, is kept.
+ */
+function mergeCollaborators(known, incoming) {
+    const incomingNameWins = !!incoming.uid && !known.uid && incoming.name.trim().length > 0;
+    return {
+        id: known.id,
+        name: incomingNameWins ? incoming.name : known.name,
+        uid: known.uid || incoming.uid,
+        handle: known.handle || incoming.handle,
+        avatarUrl: known.avatarUrl || incoming.avatarUrl,
+        avatarIcon: known.avatarIcon || incoming.avatarIcon,
+        color: known.color || incoming.color,
     };
 }
 export function LiveEditorCollaborators(props) {
-    const { awareness, collaborators = [], max = 5, size = 24 } = props;
+    const { awareness, collaborators = [], max = 5, size = 24, onNavigate, } = props;
     const [present, setPresent] = useState([]);
     useEffect(() => {
         if (!awareness) {
@@ -73,31 +87,57 @@ export function LiveEditorCollaborators(props) {
         };
     }, [awareness]);
     const faces = useMemo(() => {
-        // Who is here leads; who merely belongs completes. Folded by id and
-        // then by name: the same person often arrives twice — once under their
-        // platform uid, once under the identity the room gave them.
-        const merged = new Map();
-        const byName = new Map();
-        for (const collaborator of [...present, ...collaborators]) {
-            const nameKey = collaborator.name.trim().toLowerCase();
-            const key = merged.has(collaborator.id)
-                ? collaborator.id
-                : (byName.get(nameKey) ?? collaborator.id);
-            const known = merged.get(key);
-            if (!known) {
-                merged.set(key, collaborator);
-                byName.set(nameKey, key);
+        // Who is here leads; who merely belongs completes. One person, though,
+        // arrives more than once and never quite the same: the room knows them by
+        // their handle and a cursor name ("eric"), the grants by their uid and
+        // their full name ("Eric Charles"). Neither their id nor their name is
+        // shared, so a fold on either alone leaves two faces of one person — and
+        // two faces means two hover cards over the one avatar. So they are folded
+        // on ANY identity they have in common — uid, handle, name, or id — and the
+        // fuller of the two records is the one that survives.
+        const list = [];
+        const indexByToken = new Map();
+        const tokensOf = (person) => {
+            const tokens = [];
+            if (person.uid) {
+                tokens.push(`uid:${person.uid}`);
+            }
+            if (person.handle) {
+                tokens.push(`handle:${person.handle.trim().toLowerCase()}`);
+            }
+            const nameKey = person.name.trim().toLowerCase();
+            if (nameKey) {
+                tokens.push(`name:${nameKey}`);
+            }
+            tokens.push(`id:${person.id}`);
+            return tokens;
+        };
+        for (const person of [...present, ...collaborators]) {
+            const tokens = tokensOf(person);
+            let index = -1;
+            for (const token of tokens) {
+                const found = indexByToken.get(token);
+                if (found !== undefined) {
+                    index = found;
+                    break;
+                }
+            }
+            if (index === -1) {
+                index = list.length;
+                list.push({ ...person });
             }
-            else if ((!known.avatarIcon && collaborator.avatarIcon) ||
-                (!known.avatarUrl && collaborator.avatarUrl)) {
-                merged.set(key, {
-                    ...known,
-                    avatarIcon: known.avatarIcon || collaborator.avatarIcon,
-                    avatarUrl: known.avatarUrl || collaborator.avatarUrl,
-                });
+            else {
+                list[index] = mergeCollaborators(list[index], person);
+            }
+            // Every identity this person carries now points at their one face, so
+            // the next record that shares any of them folds in rather than doubling.
+            for (const token of [...tokens, ...tokensOf(list[index])]) {
+                if (!indexByToken.has(token)) {
+                    indexByToken.set(token, index);
+                }
             }
         }
-        return Array.from(merged.values()).slice(0, max);
+        return list.slice(0, max);
     }, [collaborators, max, present]);
     if (!faces.length) {
         return null;
@@ -112,6 +152,11 @@ export function LiveEditorCollaborators(props) {
      * opens back over the space it came from — empty by construction, since
      * the stack was collapsed there a moment before.
      */
-    _jsx(AvatarStack, { alignRight: true, size: size, children: faces.map(face => (_jsx(PrincipalAvatar, { kind: "personal", size: size, alt: face.name, avatarUrl: face.avatarUrl, avatarIcon: face.avatarIcon, square: false }, face.id))) }));
+    _jsx(AvatarStack, { alignRight: true, size: size, children: faces.map(face => (_jsx(PrincipalHoverCard
+        // A key that does not flip as the room's awareness churns: the same
+        // person arrives now under their uid, now under a client id, and a
+        // key that followed that would unmount the hover card mid-open and
+        // leak its overlay. Their identity, not their arrival, names them.
+        , { kind: "personal", uid: face.uid, handle: face.handle, displayName: face.name, name: face.name, avatarUrl: face.avatarUrl, avatarIcon: face.avatarIcon, onNavigate: onNavigate, children: _jsx(PrincipalAvatar, { kind: "personal", size: size, alt: face.name, avatarUrl: face.avatarUrl, avatarIcon: face.avatarIcon, square: false }) }, face.uid || face.handle || face.name.trim().toLowerCase()))) }));
 }
 export default LiveEditorCollaborators;

package/lib/components/collaboration/index.js

@@ -2,8 +2,4 @@
  * Copyright (c) 2023-2025 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-/*
- * Copyright (c) 2023-2026 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
 export * from './LiveEditorCollaborators.js';

package/lib/components/confetti/ConfettiSuccess.d.ts

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

package/lib/components/contents/ContentSourceCard.d.ts

@@ -0,0 +1,8 @@
+import type { CatalogSource } from '../../api/contents';
+export type ContentSourceCardProps = {
+    item: CatalogSource;
+    onOpen?: (sourceUid: string) => void;
+};
+/** Compact, host-neutral catalog row shared by Datalayer clients. */
+export declare const ContentSourceCard: ({ item, onOpen }: ContentSourceCardProps) => import("react").JSX.Element;
+export default ContentSourceCard;

package/lib/components/contents/ContentSourceCard.js

@@ -0,0 +1,23 @@
+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 { Label, Text } from '@primer/react';
+import { Box } from '@datalayer/primer-addons';
+import { contentSourceEffectiveRole, contentSourceLabel, } from '../../models/contents/index.js';
+/** Compact, host-neutral catalog row shared by Datalayer clients. */
+export const ContentSourceCard = ({ item, onOpen }) => (_jsx(Box, { as: "li", onClick: () => onOpen?.(item.source.uid), sx: {
+        p: 3,
+        borderBottom: '1px solid',
+        borderColor: 'border.muted',
+        cursor: onOpen ? 'pointer' : 'default',
+        ':last-child': { borderBottom: 0 },
+        ':hover': onOpen ? { bg: 'canvas.subtle' } : undefined,
+    }, children: _jsxs(Box, { sx: { display: 'flex', justifyContent: 'space-between', gap: 3 }, children: [_jsxs(Box, { sx: { minWidth: 0 }, children: [_jsx(Text, { sx: { fontWeight: 600 }, children: item.source.name }), _jsx(Text, { as: "p", sx: { color: 'fg.muted', fontSize: 0, m: 0, mt: 1 }, children: item.source.description || contentSourceLabel(item.source.kind) }), _jsx(Text, { as: "p", sx: { color: 'fg.subtle', fontSize: 0, m: 0, mt: 1 }, children: item.source.uid })] }), _jsxs(Box, { sx: {
+                    display: 'flex',
+                    alignItems: 'center',
+                    gap: 2,
+                    flexShrink: 0,
+                }, children: [_jsx(Label, { children: contentSourceLabel(item.source.kind) }), _jsx(Label, { variant: item.source.status === 'ready' ? 'success' : 'secondary', children: item.source.status }), _jsx(Label, { variant: "accent", children: contentSourceEffectiveRole(item) })] })] }) }));
+export default ContentSourceCard;

package/lib/components/contents/HomeFolderObjectsBrowser.d.ts

@@ -0,0 +1,10 @@
+import type { ContentObject } from '../../api/contents';
+export type HomeFolderObjectsBrowserProps = {
+    prefix?: string;
+    selectedObjectUids?: readonly string[];
+    onSelectedObjectsChange?: (objects: ContentObject[]) => void;
+    selectionDisabled?: boolean;
+};
+/** Browser for the server-managed Home Folder metadata and version history. */
+export declare const HomeFolderObjectsBrowser: ({ prefix, selectedObjectUids, onSelectedObjectsChange, selectionDisabled }: HomeFolderObjectsBrowserProps) => import("react").JSX.Element;
+export default HomeFolderObjectsBrowser;

package/lib/components/contents/HomeFolderObjectsBrowser.js

@@ -0,0 +1,148 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { useRef, useState } from 'react';
+import { Button, Checkbox, Heading, Label, ProgressBar, Spinner, Text, } from '@primer/react';
+import { DownloadIcon, FileIcon, HistoryIcon, SyncIcon, TrashIcon, UploadIcon, } from '@primer/octicons-react';
+import { Box } from '@datalayer/primer-addons';
+import { useDeleteHomeFolderObject, useDownloadHomeFolderObject, useRestoreHomeFolderObject, useUploadHomeFolderFile, useHomeFolderObjects, useHomeFolderObjectVersions, } from '../../hooks/useContents.js';
+const formatBytes = (bytes) => {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 ** 2)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 ** 3)
+        return `${(bytes / 1024 ** 2).toFixed(1)} MB`;
+    return `${(bytes / 1024 ** 3).toFixed(1)} GB`;
+};
+const mutationKey = (action, uid) => {
+    const random = typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
+        ? crypto.randomUUID()
+        : `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    return `${action}:${uid}:${random}`;
+};
+/** Browser for the server-managed Home Folder metadata and version history. */
+export const HomeFolderObjectsBrowser = ({ prefix, selectedObjectUids = [], onSelectedObjectsChange, selectionDisabled = false }) => {
+    const objects = useHomeFolderObjects({ prefix, limit: 100 });
+    const [selected, setSelected] = useState();
+    const [uploadProgress, setUploadProgress] = useState();
+    const [failedUpload, setFailedUpload] = useState();
+    const fileInput = useRef(null);
+    const versions = useHomeFolderObjectVersions(selected?.uid);
+    const deleteObject = useDeleteHomeFolderObject();
+    const restoreObject = useRestoreHomeFolderObject();
+    const uploadObject = useUploadHomeFolderFile();
+    const downloadObject = useDownloadHomeFolderObject();
+    const selectable = Boolean(onSelectedObjectsChange);
+    const toggleSelection = (object) => {
+        if (!onSelectedObjectsChange)
+            return;
+        const selectedUids = new Set(selectedObjectUids);
+        selectedUids.has(object.uid) ? selectedUids.delete(object.uid) : selectedUids.add(object.uid);
+        onSelectedObjectsChange((objects.data?.items ?? []).filter(item => selectedUids.has(item.uid)));
+    };
+    const onUpload = (file, overwrite = 'reject') => {
+        if (!file)
+            return;
+        setFailedUpload(undefined);
+        setUploadProgress({ uploaded: 0, total: file.size });
+        uploadObject.mutate({
+            path: prefix ? `${prefix.replace(/\/$/, '')}/${file.name}` : file.name,
+            content: file,
+            mediaType: file.type || 'application/octet-stream',
+            overwrite,
+            idempotencyKey: mutationKey('upload', file.name),
+            onProgress: progress => setUploadProgress({
+                uploaded: progress.uploadedBytes,
+                total: progress.totalBytes,
+            }),
+        }, {
+            onError: () => setFailedUpload(file),
+            onSettled: () => setUploadProgress(undefined),
+        });
+    };
+    const onDownload = (object) => {
+        downloadObject.mutate({ objectUid: object.uid }, {
+            onSuccess: response => {
+                const url = URL.createObjectURL(new Blob([response.data], { type: object.mediaType }));
+                const anchor = document.createElement('a');
+                anchor.href = url;
+                anchor.download = object.path.split('/').pop() || 'download';
+                anchor.click();
+                URL.revokeObjectURL(url);
+            },
+        });
+    };
+    const onDelete = (object) => {
+        if (typeof window !== 'undefined' &&
+            !window.confirm(`Delete ${object.path}? You can restore an earlier version.`)) {
+            return;
+        }
+        deleteObject.mutate({
+            objectUid: object.uid,
+            idempotencyKey: mutationKey('delete', object.uid),
+        });
+    };
+    if (objects.isPending) {
+        return (_jsx(Box, { sx: { p: 4, display: 'flex', justifyContent: 'center' }, children: _jsx(Spinner, {}) }));
+    }
+    if (objects.isError) {
+        return (_jsxs(Box, { sx: { p: 3, border: '1px solid', borderColor: 'danger.muted' }, children: [_jsx(Text, { sx: { color: 'danger.fg' }, children: objects.error instanceof Error
+                        ? objects.error.message
+                        : 'The Home Folder could not be loaded.' }), _jsx(Button, { sx: { ml: 2 }, onClick: () => objects.refetch(), children: "Retry" })] }));
+    }
+    return (_jsxs(Box, { children: [_jsxs(Box, { sx: {
+                    mb: 3,
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'space-between',
+                    gap: 3,
+                }, children: [_jsx(Text, { sx: { color: 'fg.muted' }, children: prefix ? `home-folder:///${prefix}` : 'home-folder:///' }), _jsxs(_Fragment, { children: [_jsx("input", { ref: fileInput, type: "file", hidden: true, onChange: event => {
+                                    onUpload(event.target.files?.[0]);
+                                    event.target.value = '';
+                                } }), _jsx(Button, { leadingVisual: UploadIcon, disabled: uploadObject.isPending, onClick: () => fileInput.current?.click(), children: "Upload" })] })] }), uploadProgress && (_jsxs(Box, { sx: { mb: 3 }, children: [_jsx(ProgressBar, { progress: uploadProgress.total
+                            ? (uploadProgress.uploaded / uploadProgress.total) * 100
+                            : 100, "aria-label": "Upload progress" }), _jsxs(Text, { sx: { color: 'fg.muted', fontSize: 0 }, children: [formatBytes(uploadProgress.uploaded), " of", ' ', formatBytes(uploadProgress.total)] })] })), uploadObject.isError && (_jsxs(Box, { sx: { mb: 3 }, children: [_jsx(Text, { as: "p", sx: { color: 'danger.fg', mb: 2 }, children: uploadObject.error.message }), failedUpload && (_jsxs(Box, { sx: { display: 'flex', gap: 2 }, children: [_jsx(Button, { size: "small", onClick: () => onUpload(failedUpload), children: "Retry" }), _jsx(Button, { size: "small", variant: "primary", onClick: () => onUpload(failedUpload, 'new-version'), children: "Upload as new version" })] }))] })), (objects.data?.items.length ?? 0) === 0 ? (_jsxs(Box, { sx: {
+                    p: 4,
+                    textAlign: 'center',
+                    border: '1px dashed',
+                    borderColor: 'border.default',
+                    borderRadius: 2,
+                }, children: [_jsx(FileIcon, { size: 24 }), _jsx(Heading, { as: "h3", sx: { fontSize: 2, mt: 2 }, children: "Your Home Folder is empty" }), _jsx(Text, { as: "p", sx: { color: 'fg.muted', mb: 0 }, children: "Uploaded and transferred files will appear here." })] })) : (_jsxs(Box, { as: "table", sx: {
+                    width: '100%',
+                    borderCollapse: 'collapse',
+                    'th, td': {
+                        px: 3,
+                        py: 2,
+                        textAlign: 'left',
+                        borderBottom: '1px solid',
+                        borderColor: 'border.muted',
+                    },
+                    th: { color: 'fg.muted', fontSize: 0, fontWeight: 600 },
+                }, children: [_jsx("thead", { children: _jsxs("tr", { children: [selectable && _jsx("th", { "aria-label": "Select" }), _jsx("th", { children: "Path" }), _jsx("th", { children: "Size" }), _jsx("th", { children: "Updated" }), _jsx("th", { "aria-label": "Actions" })] }) }), _jsx("tbody", { children: objects.data?.items.map(object => (_jsxs("tr", { children: [selectable && (_jsx("td", { children: _jsx(Checkbox, { "aria-label": `Select ${object.path}`, checked: selectedObjectUids.includes(object.uid), disabled: selectionDisabled || !object.currentVersionUid, onChange: () => toggleSelection(object) }) })), _jsx("td", { children: _jsxs(Box, { sx: { display: 'flex', alignItems: 'center', gap: 2 }, children: [_jsx(FileIcon, {}), _jsx(Text, { sx: { fontFamily: 'mono' }, children: object.path })] }) }), _jsx("td", { children: formatBytes(object.size) }), _jsx("td", { children: new Date(object.updatedAt).toLocaleString() }), _jsx("td", { children: _jsxs(Box, { sx: { display: 'flex', justifyContent: 'flex-end', gap: 2 }, children: [_jsx(Button, { size: "small", leadingVisual: HistoryIcon, onClick: () => setSelected(object), children: "Versions" }), _jsx(Button, { size: "small", leadingVisual: DownloadIcon, disabled: downloadObject.isPending, onClick: () => onDownload(object), children: "Download" }), _jsx(Button, { size: "small", variant: "danger", leadingVisual: TrashIcon, disabled: deleteObject.isPending, onClick: () => onDelete(object), children: "Delete" })] }) })] }, object.uid))) })] })), selected && (_jsxs(Box, { sx: {
+                    mt: 3,
+                    p: 3,
+                    border: '1px solid',
+                    borderColor: 'border.default',
+                    borderRadius: 2,
+                }, children: [_jsxs(Box, { sx: { display: 'flex', justifyContent: 'space-between', gap: 2 }, children: [_jsxs(Heading, { as: "h3", sx: { fontSize: 2 }, children: ["Versions of ", selected.path] }), _jsx(Button, { size: "small", onClick: () => setSelected(undefined), children: "Close" })] }), versions.isPending ? (_jsx(Spinner, { size: "small" })) : versions.isError ? (_jsx(Text, { sx: { color: 'danger.fg' }, children: "Version history could not be loaded." })) : (_jsx(Box, { as: "ul", sx: { listStyle: 'none', p: 0, mb: 0 }, children: versions.data?.items.map(version => {
+                            const isCurrent = version.uid === selected.currentVersionUid;
+                            return (_jsxs(Box, { as: "li", sx: {
+                                    py: 2,
+                                    display: 'flex',
+                                    alignItems: 'center',
+                                    justifyContent: 'space-between',
+                                    gap: 3,
+                                    borderBottom: '1px solid',
+                                    borderColor: 'border.muted',
+                                    ':last-child': { borderBottom: 0 },
+                                }, children: [_jsxs(Box, { children: [_jsx(Text, { sx: { fontFamily: 'mono', fontSize: 0 }, children: version.uid }), _jsxs(Text, { as: "p", sx: { color: 'fg.muted', m: 0, fontSize: 0 }, children: [new Date(version.createdAt).toLocaleString(), " \u00B7", ' ', formatBytes(version.size)] })] }), isCurrent ? (_jsx(Label, { variant: "success", children: "Current" })) : version.deleted ? (_jsx(Label, { children: "Deletion marker" })) : (_jsx(Button, { size: "small", leadingVisual: SyncIcon, disabled: restoreObject.isPending, onClick: () => restoreObject.mutate({
+                                            objectUid: selected.uid,
+                                            versionUid: version.uid,
+                                            idempotencyKey: mutationKey('restore', version.uid),
+                                        }), children: "Restore" }))] }, version.uid));
+                        }) }))] }))] }));
+};
+export default HomeFolderObjectsBrowser;

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

@@ -0,0 +1,2 @@
+export * from './ContentSourceCard';
+export * from './HomeFolderObjectsBrowser';

package/lib/components/contents/index.js

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

package/lib/components/context/OrganizationSelect.d.ts

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

package/lib/components/display/AvatarSkeleton.d.ts

@@ -1,5 +1,5 @@
 type IAvatarSkeletonProps = {
     size?: number;
 };
-export declare const AvatarSkeleton: (props: IAvatarSkeletonProps) => import("react/jsx-runtime").JSX.Element;
+export declare const AvatarSkeleton: (props: IAvatarSkeletonProps) => import("react").JSX.Element;
 export default AvatarSkeleton;

package/lib/components/display/BusyDots.d.ts

@@ -5,5 +5,5 @@ type BusyDotsProps = {
     ariaLabel?: string;
     intervalMs?: number;
 };
-export declare function BusyDots({ color, fontSize, ml, ariaLabel, intervalMs, }: BusyDotsProps): import("react/jsx-runtime").JSX.Element;
+export declare function BusyDots({ color, fontSize, ml, ariaLabel, intervalMs, }: BusyDotsProps): import("react").JSX.Element;
 export default BusyDots;

package/lib/components/display/CenteredSpinner.d.ts

@@ -7,5 +7,5 @@ type ICenteredSpinnerProps = {
     message?: string;
     size?: keyof typeof sizeMap;
 };
-export declare const CenteredSpinner: ({ message, size, }: ICenteredSpinnerProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CenteredSpinner: ({ message, size, }: ICenteredSpinnerProps) => import("react").JSX.Element;
 export default CenteredSpinner;

package/lib/components/display/CodePreview.d.ts

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

package/lib/components/display/DatalayerBox.d.ts

@@ -2,9 +2,14 @@ import type { PropsWithChildren, ReactNode } from 'react';
 type DatalayerBoxProps = {
     id?: string;
     title: string;
-    titleAction?: ReactNode;
     linkLabel?: string;
     linkRoute?: string;
+    /**
+     * What sits next to the title, e.g. the mark that explains the box.
+     *
+     * The link on the trailing edge leads somewhere; this stays here.
+     */
+    titleAction?: ReactNode;
 };
-export declare const DatalayerBox: (props: PropsWithChildren<DatalayerBoxProps>) => import("react/jsx-runtime").JSX.Element;
+export declare const DatalayerBox: (props: PropsWithChildren<DatalayerBoxProps>) => import("react").JSX.Element;
 export default DatalayerBox;

package/lib/components/display/DatalayerBox.js

@@ -15,12 +15,12 @@ export const DatalayerBox = (props) => {
                     alignItems: 'center',
                     justifyContent: 'space-between',
                     paddingRight: 4,
-                }, children: [_jsx(Text, { as: "h2", sx: { borderLeft: '6px solid #28b899', paddingLeft: 2 }, children: title }), (titleAction || (linkRoute && linkLabel)) && (_jsxs(Box, { sx: { display: 'flex', alignItems: 'center', gap: 2 }, children: [titleAction, linkRoute && linkLabel && (_jsxs(Link, { href: "javascript: return false;", onClick: e => navigate(linkRoute), sx: {
-                                    display: 'inline-flex',
-                                    alignItems: 'center',
-                                    gap: 1,
-                                    whiteSpace: 'nowrap',
-                                }, children: [linkLabel, _jsx(ArrowRightIcon, {})] }))] }))] }), _jsx(Box, { sx: {
+                }, children: [_jsxs(Box, { sx: { display: 'flex', alignItems: 'center', gap: 1 }, children: [_jsx(Text, { as: "h2", sx: { borderLeft: '6px solid #28b899', paddingLeft: 2 }, children: title }), titleAction] }), linkRoute && linkLabel && (_jsxs(Link, { href: "javascript: return false;", onClick: e => navigate(linkRoute), sx: {
+                            display: 'inline-flex',
+                            alignItems: 'center',
+                            gap: 1,
+                            whiteSpace: 'nowrap',
+                        }, children: [linkLabel, _jsx(ArrowRightIcon, {})] }))] }), _jsx(Box, { sx: {
                     borderColor: 'border.default',
                     borderStyle: 'solid',
                     borderWidth: '1',

package/lib/components/display/HorizontalCenter.d.ts

@@ -2,5 +2,5 @@ import { PropsWithChildren } from 'react';
 type IHorizontalCenterProps = {
     margin?: string;
 };
-export declare const HorizontalCenter: ({ children, margin, }: PropsWithChildren<IHorizontalCenterProps>) => import("react/jsx-runtime").JSX.Element;
+export declare const HorizontalCenter: ({ children, margin, }: PropsWithChildren<IHorizontalCenterProps>) => import("react").JSX.Element;
 export default HorizontalCenter;

package/lib/components/display/JupyterDialog.d.ts

@@ -1,3 +1,4 @@
+import type { JSX } from 'react';
 import { JSXElementConstructor, PropsWithChildren } from 'react';
 import { Dialog } from '@jupyterlab/apputils';
 import { ReactWidget } from '@jupyterlab/ui-components';

package/lib/components/display/JupyterDialog.js

@@ -1,8 +1,4 @@
 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 { createElement, useState, } from 'react';
 import { Dialog } from '@jupyterlab/apputils';
 import { ReactWidget } from '@jupyterlab/ui-components';
@@ -58,9 +54,7 @@ export class JupyterDialog extends ReactWidget {
     }
     _renderBody = (props) => {
         const pending = this._pendingButtonIndex !== null;
-        return (_jsx(PrimerDialog.Body, { children: _jsx("div", { "aria-busy": pending, ...(pending ? { inert: '' } : {}), style: pending
-                    ? { pointerEvents: 'none', opacity: 0.6 }
-                    : undefined, children: createElement(this.body, {
+        return (_jsx(PrimerDialog.Body, { children: _jsx("div", { "aria-busy": pending, ...(pending ? { inert: '' } : {}), style: pending ? { pointerEvents: 'none', opacity: 0.6 } : undefined, children: createElement(this.body, {
                     ...props,
                     setValue: this.setValue,
                     pending,

package/lib/components/display/Markdown.d.ts

@@ -1,3 +1,4 @@
+import type { JSX } from 'react';
 import type { IMarkdownParser, IRenderMime } from '@jupyterlab/rendermime';
 /**
  * {@link Markdown} properties

package/lib/components/display/NotebookSkeleton.d.ts

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

package/lib/components/display/Placeholder.d.ts

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