@datalayer/core 0.0.1 → 0.0.3

package/lib/hooks/useAIAgents.js

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { URLExt } from '@jupyterlab/coreutils';
+import { useCoreStore } from '../state';
+import { useDatalayer } from './useDatalayer';
+export const useAIAgents = (baseUrlOverride = 'api/ai-agents/v1') => {
+    const { configuration } = useCoreStore();
+    const { requestDatalayer } = useDatalayer({ notifyOnError: false });
+    const createAIAgent = (documentId, documentType, ingress, token, kernelId, { signal, baseUrl = baseUrlOverride } = {}) => {
+        return requestDatalayer({
+            url: URLExt.join(configuration.aiagentsRunUrl, baseUrl, 'agents'),
+            method: 'POST',
+            body: {
+                document_id: documentId,
+                document_type: documentType,
+                runtime: {
+                    ingress,
+                    token,
+                    kernel_id: kernelId,
+                }
+            },
+            signal
+        });
+    };
+    const getAIAgents = ({ signal, baseUrl = baseUrlOverride } = {}) => {
+        return requestDatalayer({
+            url: URLExt.join(configuration.aiagentsRunUrl, baseUrl, 'agents'),
+            method: 'GET',
+            signal,
+        });
+    };
+    const deleteAIAgent = (documentId, { signal, baseUrl = baseUrlOverride } = {}) => {
+        return requestDatalayer({
+            url: URLExt.join(configuration.aiagentsRunUrl, baseUrl, 'agents', documentId),
+            method: 'DELETE',
+            signal,
+        });
+    };
+    const getAIAgent = (documentId, { signal, baseUrl = baseUrlOverride } = {}) => {
+        return requestDatalayer({
+            url: URLExt.join(configuration.aiagentsRunUrl, baseUrl, 'agents', documentId),
+            method: 'GET',
+            signal,
+        });
+    };
+    const patchAIAgent = (documentId, ingress, token, kernelId, { signal, baseUrl = baseUrlOverride } = {}) => {
+        return requestDatalayer({
+            url: URLExt.join(configuration.aiagentsRunUrl, baseUrl, 'agents', documentId),
+            method: 'PATCH',
+            body: {
+                runtime: ingress && token && kernelId
+                    ? {
+                        ingress,
+                        token,
+                        kernel_id: kernelId
+                    }
+                    : null
+            },
+            signal,
+        });
+    };
+    return {
+        createAIAgent,
+        getAIAgents,
+        deleteAIAgent,
+        getAIAgent,
+        patchAIAgent
+    };
+};
+export default useAIAgents;

package/lib/hooks/useAuthorization.d.ts

@@ -0,0 +1,19 @@
+import { IAnyOrganization, IOrganizationMember, IUser, ITeam, TeamMember, IAnyTeam } from '../models';
+export declare const useAuthorization: () => {
+    checkIsCourseStudent: (user: IUser, course: string) => boolean;
+    checkIsOrganizationMember: (user: IUser, organization: IAnyOrganization) => boolean;
+    checkUserIsOrganizationOwner: (user: IUser, organization: IAnyOrganization) => boolean;
+    checkIsPlatformAdmin: (user: IUser) => boolean;
+    checkIsPlatformFeaturesPreviewer: (user: IUser) => boolean;
+    checkIsPlatformGrowthManager: (user: IUser) => boolean;
+    checkIsPlatformMember: (user: IUser) => boolean;
+    checkIsPlatformSuccessManager: (user: IUser) => boolean;
+    checkIsPlatformUsageReviewer: (user: IUser) => boolean;
+    checkIsTeamMember: (user: IUser, team: ITeam) => boolean;
+    checkIsTeamOwer: (member: TeamMember) => boolean;
+    checkOrganizationsMembership: (organizationHandle: string, organizations?: IAnyOrganization[]) => void;
+    checkUserAccountPermissions: (user: IUser, accountHandle: string) => void;
+    checkIsOrganizationOwner: (member: IOrganizationMember) => boolean;
+    checkUserIsTeamOwer: (user: IUser, team: IAnyTeam) => boolean;
+};
+export default useAuthorization;

package/lib/hooks/useAuthorization.js

@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { useLocation } from "react-router-dom";
+import { PlatformRoles, OrganizationRoles, TeamRoles } from '../models';
+import useNavigate from "./useNavigate";
+export const useAuthorization = () => {
+    const navigate = useNavigate();
+    const location = useLocation();
+    const goToApplicationStateError = (message) => {
+        console.warn(message);
+        console.log("Application error while navigating to ", location);
+        console.trace();
+        navigate('/error/application/state');
+    };
+    // Account -------------------------------------------------------------------
+    const checkUserAccountPermissions = (user, accountHandle) => {
+        if (user.handle !== accountHandle) {
+            goToApplicationStateError(`Permissions check failed for account handle: ${accountHandle} and user: ${user}`);
+        }
+    };
+    // Platform -------------------------------------------------------------------
+    const checkIsPlatformAdmin = (user) => {
+        return user.roles.includes(PlatformRoles.Admin.handle);
+    };
+    const checkIsPlatformGrowthManager = (user) => {
+        return user.roles.includes(PlatformRoles.GrowthManager.handle);
+    };
+    const checkIsPlatformSuccessManager = (user) => {
+        return user.roles.includes(PlatformRoles.SuccessManager.handle);
+    };
+    const checkIsPlatformMember = (user) => {
+        return user.roles.includes(PlatformRoles.Member.handle);
+    };
+    const checkIsPlatformFeaturesPreviewer = (user) => {
+        return user.roles.includes(PlatformRoles.FeaturesPreviewer.handle);
+    };
+    const checkIsPlatformUsageReviewer = (user) => {
+        return user.roles.includes(PlatformRoles.UsageReviewer.handle);
+    };
+    // Organization -------------------------------------------------------------------
+    const checkUserIsOrganizationOwner = (user, organization) => {
+        for (let i = 0; i < organization.members.length; i++) {
+            if (organization.members[i].id === user.id) {
+                if (checkIsOrganizationOwner(organization.members[i])) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+    const checkIsOrganizationOwner = (member) => {
+        return member.roles.includes(OrganizationRoles.Owner.handle);
+    };
+    const checkIsOrganizationMember = (user, organization) => {
+        for (let i = 0; i < organization.members.length; i++) {
+            if (organization.members[i].id === user.id) {
+                return true;
+            }
+        }
+        return false;
+    };
+    const checkOrganizationsMembership = (organizationHandle, organizations) => {
+        if (organizations) {
+            let isAllowed = false;
+            for (let i = 0; i < organizations.length; i++) {
+                if (organizationHandle === organizations[i].handle) {
+                    isAllowed = true;
+                    break;
+                }
+            }
+            if (!isAllowed) {
+                goToApplicationStateError(`Check organizations membership fails for organization handle: ${organizationHandle} and organizations: ${organizations}`);
+            }
+        }
+    };
+    // Team -------------------------------------------------------------------
+    const checkUserIsTeamOwer = (user, team) => {
+        for (let i = 0; i < team.members.length; i++) {
+            if (team.members[i].id === user.id) {
+                if (checkIsTeamOwer(team.members[i])) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+    const checkIsTeamOwer = (member) => {
+        return member.roles.includes(TeamRoles.Owner.handle);
+    };
+    const checkIsTeamMember = (user, team) => {
+        for (let i = 0; i < team.members.length; i++) {
+            if (team.members[i].id === user.id) {
+                return true;
+            }
+        }
+        return false;
+    };
+    // Course -------------------------------------------------------------------
+    const checkIsCourseStudent = (user, course) => {
+        // TODO Implement this.
+        return false;
+    };
+    // --------------------------------------------------------------------------
+    return {
+        checkIsCourseStudent,
+        checkIsOrganizationMember,
+        checkUserIsOrganizationOwner,
+        checkIsPlatformAdmin,
+        checkIsPlatformFeaturesPreviewer,
+        checkIsPlatformGrowthManager,
+        checkIsPlatformMember,
+        checkIsPlatformSuccessManager,
+        checkIsPlatformUsageReviewer,
+        checkIsTeamMember,
+        checkIsTeamOwer,
+        checkOrganizationsMembership,
+        checkUserAccountPermissions,
+        checkIsOrganizationOwner,
+        checkUserIsTeamOwer,
+    };
+};
+export default useAuthorization;

package/lib/hooks/useBackdrop.d.ts

@@ -0,0 +1,28 @@
+import PropTypes from 'prop-types';
+type BackdropContextType = {
+    closeBackdrop: () => void;
+    displayBackdrop: (nextBackdrop: any) => void;
+};
+export declare const BackdropContext: import("react").Context<BackdropContextType>;
+export declare function useBackdrop(): BackdropContextType;
+/**
+ * The type for the Backdrop context provider.
+ */
+export declare const BackdropContextProvider: import("react").Provider<BackdropContextType>;
+type IBackdropProviderProps = {
+    children?: JSX.Element | JSX.Element[];
+    zIndex?: number;
+    disableDarken?: boolean;
+    backdropSurface?: any;
+};
+export declare function BackdropProvider(props: IBackdropProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace BackdropProvider {
+    var propTypes: {
+        children: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        zIndex: PropTypes.Requireable<number>;
+        disableDarken: PropTypes.Requireable<boolean>;
+        backdropSurface: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    var defaultProps: IBackdropProviderProps;
+}
+export {};

package/lib/hooks/useBackdrop.js

@@ -0,0 +1,100 @@
+import { Fragment as _Fragment, 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 { createContext, useState, useContext } from 'react';
+import PropTypes from 'prop-types';
+import { LayoutBackdrop } from "./layouts";
+export const BackdropContext = createContext({
+    closeBackdrop: () => { },
+    displayBackdrop: (nextBackdrop) => { },
+});
+export function useBackdrop() {
+    const context = useContext(BackdropContext);
+    if (!context)
+        throw new Error('useContext must be inside a provider with a value.');
+    return context;
+}
+/**
+ * The type for the Backdrop context provider.
+ */
+export const BackdropContextProvider = BackdropContext.Provider;
+/*
+Example
+-------
+import React from 'react'
+import { BackdropProvider } from 'use-backdrop';
+import ExampleComponent from './ExampleComponent'
+const renderCustomBackdropSurface = (children) => (
+  <div style={{
+    // Style your own backdrop surface!
+    position: 'fixed',
+    top: 0,
+    left: 0,
+    height: '100vh',
+    width: '100vw',
+    backgroundColor: 'rgba(0, 0, 0, 0.5)',
+  }}>
+    {children}
+  </div>
+)
+const App = () => (
+  <BackdropProvider
+    backdropSurface={renderCustomBackdropSurface}
+  >
+    <ExampleComponent />
+  </BackdropProvider>
+)
+export default App
+*/
+export function BackdropProvider(props) {
+    const { children, zIndex, disableDarken, backdropSurface } = props;
+    const defaultBackdropSurface = {
+        position: "fixed",
+        top: 0,
+        left: 0,
+        width: '100%',
+        height: '100%',
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'center',
+        backgroundColor: disableDarken ? 'initial' : 'rgba(0, 0, 0, 0.5)',
+        zIndex,
+    };
+    const [backdrop, setBackdrop] = useState({
+        open: false,
+        render: (closeBackdrop) => _jsx(_Fragment, {})
+    });
+    const displayBackdrop = (nextBackdrop) => {
+        setBackdrop({
+            open: true,
+            render: nextBackdrop
+        });
+    };
+    const closeBackdrop = () => {
+        setBackdrop({
+            open: false,
+            render: (closeBackdrop) => _jsx(_Fragment, {})
+        });
+    };
+    return (_jsxs(BackdropContextProvider, { value: { closeBackdrop, displayBackdrop }, children: [_jsx(LayoutBackdrop, {}), children, backdrop.open &&
+                (backdropSurface ? (backdropSurface(backdrop.render(closeBackdrop))) : (_jsx("div", { style: defaultBackdropSurface, children: backdrop.render(closeBackdrop) })))] }));
+}
+BackdropProvider.propTypes = {
+    children: PropTypes.element,
+    // zIndex of the backdrop surface. Unused if backdropSurface is overridden.
+    zIndex: PropTypes.number,
+    // If true, backdrop background is transparent.
+    disableDarken: PropTypes.bool,
+    // A render function that returns a Component that overrides (takes the
+    // place of) the default darkened div background.
+    // See /example/src/ExampleApp.jsx for proper use.
+    backdropSurface: PropTypes.func
+};
+BackdropProvider.defaultProps = {
+    children: undefined,
+    disableBackdrop: false,
+    zIndex: 9999,
+    backdropSurface: null
+};

package/lib/hooks/useBackdropJupyterLab.d.ts

@@ -0,0 +1,15 @@
+type JupyterLabBackdropType = {
+    open: boolean;
+    element?: JSX.Element | JSX.Element[];
+};
+declare function JupyterLabBackdrop({ open, element }: JupyterLabBackdropType): import("react/jsx-runtime").JSX.Element;
+export default JupyterLabBackdrop;
+interface JupyterLabBackdropProps {
+}
+type UseJupyterLabBackdropProps = {
+    openBackdrop: (element: JSX.Element) => void;
+    closeBackdrop: () => void;
+};
+declare const JupyterLabBackdropProvider: ({ children }: React.PropsWithChildren<JupyterLabBackdropProps>) => import("react/jsx-runtime").JSX.Element;
+declare function useJupyterLabBackdrop(): UseJupyterLabBackdropProps;
+export { useJupyterLabBackdrop, JupyterLabBackdropProvider };

package/lib/hooks/useBackdropJupyterLab.js

@@ -0,0 +1,51 @@
+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 { createContext, useState, useContext } from 'react';
+import styled from 'styled-components';
+const JupyterLabBackdropComponent = styled.div `
+  position: fixed;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  background-color: rgba(0, 0, 0, 0.3);
+  height: 100vh;
+  width: 100vw;
+  right: 0;
+  top: 0;
+  z-index: 1000000000;
+`;
+function JupyterLabBackdrop({ open, element }) {
+    return open ? _jsx(JupyterLabBackdropComponent, { children: element }) : _jsx(_Fragment, {});
+}
+export default JupyterLabBackdrop;
+const JupyterLabBackdropContext = createContext({
+    openBackdrop: (element) => {
+        /* no-op */
+    },
+    closeBackdrop: () => {
+        /* no-op */
+    }
+});
+const JupyterLabBackdropProvider = ({ children }) => {
+    const [opened, setOpened] = useState(false);
+    const [element, setElement] = useState();
+    const openBackdrop = (element) => {
+        setElement(element);
+        setOpened(true);
+    };
+    const closeBackdrop = () => {
+        setElement(undefined);
+        setOpened(false);
+    };
+    return (_jsxs(JupyterLabBackdropContext.Provider, { value: {
+            openBackdrop: openBackdrop,
+            closeBackdrop: closeBackdrop
+        }, children: [_jsx(JupyterLabBackdrop, { open: opened, element: element }), children] }));
+};
+function useJupyterLabBackdrop() {
+    return useContext(JupyterLabBackdropContext);
+}
+export { useJupyterLabBackdrop, JupyterLabBackdropProvider };