@datalayer/core 0.0.1 → 0.0.2

package/lib/state/substates/RuntimesState.js

@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+import { useStore } from 'zustand';
+import { createStore } from 'zustand/vanilla';
+import { JSONExt } from '@lumino/coreutils';
+import { Poll } from '@lumino/polling';
+import { getRuntimes } from '../../api';
+import { coreStore } from './CoreState';
+import { iamStore } from './IAMState';
+/**
+ * Kernel store
+ */
+export const runtimesStore = createStore((set, get) => {
+    return {
+        configuration: {
+            maxNotebookRuntimes: 5,
+            maxCellRuntimes: 3
+        },
+        setConfiguration: (configuration) => {
+            set(state => JSONExt.deepEqual(state.configuration, configuration)
+                ? {}
+                : { configuration: { ...configuration } });
+        },
+        runtimesRunUrl: coreStore.getState().configuration?.runtimesRunUrl,
+        setJupyterLabAdapter: (jupyterLabAdapter) => {
+            set(state => ({ jupyterLabAdapter }));
+        },
+        tab: 0.0,
+        getIntTab: () => Math.floor(get().tab),
+        setTab: (tab) => set(state => ({ tab })),
+        /**
+         * Remote runtime pods.
+         */
+        runtimePods: [],
+        /**
+         * Refresh the runtime pods.
+         */
+        refreshRuntimePods: async () => {
+            const servers = await getRuntimes();
+            // Update the state with the Remote Kernels.
+            if (!JSONExt.deepEqual(get().runtimePods, servers)) {
+                set({ runtimePods: [...servers] });
+            }
+        },
+        /**
+         * Cached runtime models.
+         */
+        runtimeModels: [],
+        /**
+         * Add a runtime model
+         */
+        addRuntimeModel: (model) => {
+            const kernels = get().runtimeModels;
+            const index = kernels.findIndex(m => model.id === m.id) ?? -1;
+            if (index < 0) {
+                set({ runtimeModels: [...kernels, model] });
+            }
+        },
+        /**
+         * Remove a runtime model by ID.
+         */
+        removeRuntimeModel: (id) => {
+            const kernels = [...get().runtimeModels];
+            const index = kernels?.findIndex(model => id === model.id) ?? -1;
+            if (index >= 0) {
+                kernels.splice(index, 1);
+                set({ runtimeModels: kernels });
+            }
+        },
+        setRuntimeModels: (models) => {
+            if (!JSONExt.deepEqual(get().runtimeModels, models)) {
+                set({ runtimeModels: [...models] });
+            }
+        },
+        multiServiceManager: undefined,
+        setMultiServiceManager: multiServiceManager => {
+            set(state => ({ multiServiceManager }));
+        },
+        showDisclaimer: false,
+        setShowDisclaimer: showDisclaimer => {
+            set(state => ({ showDisclaimer }));
+        },
+        /**
+         * Kernel Snapshots.
+         */
+        runtimeSnapshots: [],
+        /**
+         * Add a Kernel Snapshot
+         */
+        addRuntimeSnapshot: (snapshot) => {
+            const snapshots = get().runtimeSnapshots;
+            const index = snapshots.findIndex(s => s.id === snapshot.id);
+            if (index < 0) {
+                const kernelSnapshots = [...snapshots, snapshot];
+                set({ runtimeSnapshots: kernelSnapshots });
+            }
+            else if (!JSONExt.deepEqual(snapshots[index], snapshot)) {
+                const kernelSnapshots = [...snapshots];
+                kernelSnapshots.splice(index, 1, snapshot);
+                set({ runtimeSnapshots: kernelSnapshots });
+            }
+        },
+        /**
+         * Remove a Kernel Snapshot.
+         */
+        removeRuntimeSnapshot: (id) => {
+            const snapshots = get().runtimeSnapshots;
+            const index = snapshots.findIndex(s => s.id === id);
+            if (index >= 0) {
+                const kernelSnapshots = [...snapshots];
+                kernelSnapshots.splice(index, 1);
+                set({ runtimeSnapshots: kernelSnapshots });
+            }
+        },
+        /**
+         * Set Kernel Snapshots.
+         */
+        setRuntimeSnapshots: (snapshots) => {
+            if (!JSONExt.deepEqual(get().runtimeSnapshots, snapshots)) {
+                set({ runtimeSnapshots: [...snapshots] });
+            }
+        },
+        version: '',
+        setVersion: version => {
+            if (version && !get().version) {
+                set(state => ({ version }));
+            }
+        }
+    };
+});
+// Poll remote kernels
+const kernelsPoll = new Poll({
+    auto: true,
+    factory: () => runtimesStore.getState().refreshRuntimePods(),
+    frequency: {
+        interval: 61 * 1000,
+        backoff: true,
+        max: 300 * 1000
+    },
+    name: '@datalayer/jupyter-kernels:KernelsManager#kernels',
+    standby: () => iamStore.getState().token || runtimesStore.getState().runtimesRunUrl
+        ? 'when-hidden'
+        : true
+});
+// Force refresh at expiration date if next tick is after it.
+runtimesStore.subscribe((state, prevState) => {
+    if (!JSONExt.deepEqual(state.runtimePods, prevState.runtimePods)) {
+        const now = Date.now();
+        const minExpiredAt = Math.min(...state.runtimePods.map(kernel => kernel.expired_at ? parseFloat(kernel.expired_at) : Infinity)) * 1_000;
+        // Refresh 2 sec after the closest expiration time
+        // to let some times to the system to dispose the resources.
+        if (now + kernelsPoll.frequency.interval > minExpiredAt + 2_000) {
+            setTimeout(() => {
+                kernelsPoll.refresh();
+            }, minExpiredAt + 2_000 - now);
+        }
+    }
+});
+coreStore.subscribe((state, prevState) => {
+    if (state.configuration.runtimesRunUrl &&
+        state.configuration.runtimesRunUrl !== prevState.configuration.runtimesRunUrl) {
+        const runtimesRunUrl = state.configuration.runtimesRunUrl;
+        console.log(`Updating runtimesRunUrl with new value ${runtimesRunUrl}`);
+        runtimesStore.setState({ runtimesRunUrl });
+        kernelsPoll
+            .refresh()
+            .then(() => kernelsPoll.tick)
+            .catch(reason => {
+            console.error('Failed to refresh kernel servers list following service URL changed.', reason);
+        });
+    }
+});
+export function useRuntimesStore(selector) {
+    return useStore(runtimesStore, selector);
+}
+export default useRuntimesStore;

package/lib/state/substates/SpaceState.d.ts

@@ -0,0 +1,11 @@
+import { IBaseSpace } from '../../models';
+export type ISpaceState = {
+    spaces: IBaseSpace[];
+};
+export type SpaceState = ISpaceState & {
+    updateSpaces: (spaces: IBaseSpace[]) => void;
+};
+export declare const spaceStore: import("zustand").StoreApi<SpaceState>;
+export declare function useSpaceStore(): SpaceState;
+export declare function useSpaceStore<T>(selector: (state: SpaceState) => T): T;
+export default useSpaceStore;

package/lib/state/substates/SpaceState.js

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+import { createStore } from 'zustand/vanilla';
+import { useStore } from 'zustand';
+export const spaceStore = createStore((set, get) => ({
+    spaces: [],
+    updateSpaces: (spaces) => set((state) => ({
+        spaces
+    })),
+}));
+export function useSpaceStore(selector) {
+    return useStore(spaceStore, selector);
+}
+export default useSpaceStore;

package/lib/state/substates/SurveysState.d.ts

@@ -0,0 +1,14 @@
+import { ISurvey } from '../../models';
+export type ISuccessState = {
+    growthRunUrl: string;
+    surveys?: Map<string, ISurvey>;
+};
+export type SuccessState = ISuccessState & {
+    setSurveys: (surveys: Array<ISurvey>) => void;
+    refreshSurveys: () => void;
+    createSurvey: (name: string, form: any) => void;
+};
+export declare const surveysStore: import("zustand").StoreApi<SuccessState>;
+export declare function useSurveysStore(): SuccessState;
+export declare function useSurveysStore<T>(selector: (state: SuccessState) => T): T;
+export default useSurveysStore;

package/lib/state/substates/SurveysState.js

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+import { createStore } from 'zustand/vanilla';
+import { useStore } from 'zustand';
+import { requestRunAPI } from '../../api';
+import { asSurvey } from '../../models';
+import { coreStore } from './CoreState';
+import { iamStore } from './IAMState';
+export const surveysStore = createStore((set, get) => ({
+    surveys: undefined,
+    growthRunUrl: coreStore.getState().configuration?.growthRunUrl,
+    setSurveys: (s) => {
+        const surveys = new Map();
+        s.forEach(survey => surveys.set(survey.name, survey));
+        set((state) => ({ surveys }));
+    },
+    refreshSurveys: async () => {
+        const { token } = iamStore.getState();
+        const { growthRunUrl } = get();
+        try {
+            const resp = await requestRunAPI({
+                url: `${growthRunUrl}/api/growth/v1/surveys`,
+                method: 'GET',
+                token,
+            });
+            if (resp.success && resp.surveys) {
+                const surveyArray = resp.surveys.map(survey => asSurvey(survey));
+                const surveys = new Map();
+                surveyArray.forEach(survey => surveys.set(survey.name, survey));
+                set((state) => ({ surveys }));
+            }
+            else {
+                console.error('Failed to get the surveys.', resp);
+            }
+        }
+        catch (error) {
+            console.error('Failed to get the surveys.', error);
+            if (error.name === 'RunResponseError' &&
+                error.response.status === 401) {
+                console.error('Received 401, logging out.');
+            }
+            throw error;
+        }
+    },
+    createSurvey: async (name, form) => {
+        const { growthRunUrl } = get();
+        const { token } = iamStore.getState();
+        try {
+            const resp = await requestRunAPI({
+                url: `${growthRunUrl}/api/growth/v1/surveys`,
+                method: 'POST',
+                body: {
+                    name,
+                    form,
+                },
+                token,
+            });
+            if (resp.success && resp.survey) {
+                const survey = asSurvey(resp.survey);
+                const surveys = get().surveys;
+                if (surveys) {
+                    surveys.set(survey.name, survey);
+                    set((state) => ({ surveys }));
+                }
+                else {
+                    set((state) => ({ surveys: new Map([
+                            [survey.name, survey]
+                        ]) }));
+                }
+            }
+            else {
+                console.error('Failed to create the survey.', resp);
+            }
+        }
+        catch (error) {
+            console.error('Failed to create the survey.', error);
+            if (error.name === 'RunResponseError' &&
+                error.response.status === 401) {
+                console.error('Received 401, logging out.');
+            }
+            throw error;
+        }
+    },
+}));
+coreStore.subscribe((state, prevState) => {
+    if (state.configuration.successRunUrl &&
+        state.configuration.successRunUrl !== prevState.configuration.successRunUrl) {
+        const growthRunUrl = state.configuration.growthRunUrl;
+        console.log(`Updating growthRunUrl with new value ${growthRunUrl}`);
+        surveysStore.setState({ growthRunUrl });
+    }
+});
+export function useSurveysStore(selector) {
+    return useStore(surveysStore, selector);
+}
+export default useSurveysStore;

package/lib/state/substates/TeamState.d.ts

@@ -0,0 +1,11 @@
+import { IBaseTeam } from '../../models';
+export type ITeamState = {
+    teams: IBaseTeam[];
+};
+export type TeamState = ITeamState & {
+    update: (teams: IBaseTeam[]) => void;
+};
+export declare const teamStore: import("zustand").StoreApi<TeamState>;
+export declare function useTeamStore(): TeamState;
+export declare function useTeamStore<T>(selector: (state: TeamState) => T): T;
+export default useTeamStore;

package/lib/state/substates/TeamState.js

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+import { createStore } from 'zustand/vanilla';
+import { useStore } from 'zustand';
+import { TEAMS_MOCK } from '../../mocks';
+export const teamStore = createStore((set, get) => ({
+    teams: TEAMS_MOCK,
+    update: (teams) => set((state) => ({
+        teams
+    })),
+}));
+export function useTeamStore(selector) {
+    return useStore(teamStore, selector);
+}
+export default useTeamStore;

package/lib/state/substates/index.d.ts

@@ -0,0 +1,15 @@
+export * from './AIAgentState';
+export * from './CellState';
+export * from './CoreState';
+export * from './DatasourceState';
+export * from './DocumentState';
+export * from './GradeState';
+export * from './IAMState';
+export * from './JupyterLabState';
+export * from './LayoutState';
+export * from './NbformatState';
+export * from './OrganizationState';
+export * from './RuntimesState';
+export * from './SpaceState';
+export * from './SurveysState';
+export * from './TeamState';

package/lib/state/substates/index.js

@@ -0,0 +1,24 @@
+/*
+ * 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 './AIAgentState';
+export * from './CellState';
+export * from './CoreState';
+export * from './DatasourceState';
+export * from './DocumentState';
+export * from './GradeState';
+export * from './IAMState';
+export * from './JupyterLabState';
+export * from './LayoutState';
+export * from './NbformatState';
+export * from './OrganizationState';
+export * from './RuntimesState';
+export * from './SpaceState';
+export * from './SurveysState';
+export * from './TeamState';

package/lib/test-setup.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/test-setup.js

@@ -0,0 +1,7 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export {};
+// Test setup for unit tests
+// Add any global test configuration here

package/lib/theme/DatalayerTheme.d.ts

@@ -0,0 +1,37 @@
+declare const theme: {
+    animation: {
+        easeOutCubic: string;
+    };
+    borderWidths: (string | number)[];
+    breakpoints: string[];
+    fonts: {
+        normal: any;
+        mono: string;
+    };
+    fontSizes: string[];
+    fontWeights: {
+        light: number;
+        normal: number;
+        semibold: number;
+        bold: number;
+    };
+    lineHeights: {
+        condensedUltra: number;
+        condensed: number;
+        default: number;
+    };
+    radii: string[];
+    sizes: {
+        small: string;
+        medium: string;
+        large: string;
+        xlarge: string;
+    };
+    space: string[];
+} & {
+    colorSchemes: {
+        light: {};
+        dark: {};
+    };
+};
+export { theme as datalayerTheme };

package/lib/theme/DatalayerTheme.js

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+import { theme as primerTheme } from '@primer/react';
+import cloneDeep from 'lodash/cloneDeep.js';
+import merge from 'lodash/merge.js';
+/**
+ * Datalayer Theme for Primer React.
+ */
+const datalayerThemeDefs = {
+    colorSchemes: {
+        light: {
+            colors: {
+                btn: {
+                    //          text: 'var(--jp-ui-font-color1, rgba(0, 0, 0, 0.87))',
+                    //          bg: 'var(--jp-layout-color1, white)',
+                    //          border: 'var(--jp-border-color1, #bdbdbd)',
+                    //          hoverBg: 'var(--jp-layout-color2, #eee)',
+                    //          hoverBorder: 'var(--jp-border-color1, #bdbdbd)',
+                    //          activeBg: 'var(--jp-layout-color3, #bdbdbd)',
+                    //          activeBorder: 'var(--jp-border-color1, #bdbdbd)',
+                    //          selectedBg: 'var(--jp-layout-color0, white)',
+                    //          counterBg: 'var(--jp-layout-color4, #757575)',
+                    primary: {
+                        //            text: 'var(--jp-ui-inverse-font-color1, rgba(255, 255, 255, 1))',
+                        bg: 'var(--dla-color-green-dark)',
+                        //            border: 'var(--dla-color-green-light)',
+                        hoverBg: 'var(--dla-color-grey)',
+                        //            hoverBorder: 'var(--dla-color-green-light)',
+                        selectedBg: 'var(--dla-color-black)',
+                        //            disabledText: 'var(--jp-ui-inverse-font-color2, rgba(255, 255, 255, 0.7))',
+                        //            disabledBg: 'var(--jp-brand-color3, #c8e6c9)',
+                        //            disabledBorder: 'var(--jp-border-color1, #bdbdbd)',
+                        //            icon: 'var(--jp-ui-inverse-font-color2, rgba(255, 255, 255, 0.7))',
+                        //            counterBg: 'var(--jp-inverse-layout-color3, #616161)',
+                    },
+                },
+            },
+            shadows: {},
+        },
+        dark: {
+            colors: {},
+            shadows: {},
+        }
+    },
+};
+const { colorSchemes: primerSchemes, ...primerOthers } = cloneDeep(primerTheme);
+const { colorSchemes: jupyterSchemes, ...datalayerOthers } = datalayerThemeDefs;
+// Merge with the light theme to ensure all variables are defined (although the style may be ugly).
+const theme = merge(primerOthers, datalayerOthers, {
+    colorSchemes: { light: {}, dark: {} },
+});
+theme.colorSchemes.light = {
+    colors: merge(primerSchemes.light.colors, jupyterSchemes.light.colors),
+    shadows: merge(primerSchemes.light.shadows, jupyterSchemes.light.shadows),
+};
+theme.colorSchemes.dark = {
+    colors: merge(primerSchemes.dark.colors, jupyterSchemes.dark.colors),
+    shadows: merge(primerSchemes.dark.shadows, jupyterSchemes.dark.shadows),
+};
+export { theme as datalayerTheme };

package/lib/theme/DatalayerThemeProvider.d.ts

@@ -0,0 +1,17 @@
+import { type CSSProperties } from 'react';
+import { ThemeProviderProps } from '@primer/react';
+export interface IDatalayerThemeProviderProps extends ThemeProviderProps {
+    /**
+     * Whether the components is embedded in Jupyter UI or not.
+     */
+    inJupyterLab?: boolean;
+    /**
+     * Base styles
+     */
+    baseStyles?: CSSProperties;
+}
+/**
+ * ThemeProvider component changing color mode with JupyterLab theme
+ * if embedded in Jupyter or with the browser color scheme preference.
+ */
+export declare function DatalayerThemeProvider(props: React.PropsWithChildren<IDatalayerThemeProviderProps>): JSX.Element;

package/lib/theme/DatalayerThemeProvider.js

@@ -0,0 +1,74 @@
+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.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+import { useEffect, useState } from 'react';
+import { BaseStyles, ThemeProvider as PrimerThemeProvider } from '@primer/react';
+import { loadJupyterConfig, jupyterLabTheme } from '@datalayer/jupyter-react';
+import { datalayerTheme } from '../theme';
+import { useRuntimesStore } from '../state';
+/**
+ * ThemeProvider component changing color mode with JupyterLab theme
+ * if embedded in Jupyter or with the browser color scheme preference.
+ */
+export function DatalayerThemeProvider(props) {
+    const { children, colorMode: colorModeProps, 
+    //    inJupyterLab,
+    baseStyles, ...rest } = props;
+    const { jupyterLabAdapter } = useRuntimesStore();
+    const [colorMode, setColorMode] = useState(colorModeProps ?? 'light');
+    const [inJupyterLab, setInJupterLab] = useState(undefined);
+    useEffect(() => {
+        setInJupterLab(loadJupyterConfig().insideJupyterLab);
+    }, []);
+    useEffect(() => {
+        if (inJupyterLab !== undefined) {
+            function colorSchemeFromMedia({ matches }) {
+                setColorMode(matches ? 'dark' : 'light');
+            }
+            function updateColorMode(themeManager) {
+                setColorMode(themeManager.theme && !themeManager.isLight(themeManager.theme) ? 'dark' : 'light');
+            }
+            if (inJupyterLab) {
+                // TODO remove the try/catch for JupyterLab > 4.1.
+                try {
+                    const themeManager = jupyterLabAdapter?.service('@jupyterlab/apputils-extension:themes');
+                    if (themeManager) {
+                        updateColorMode(themeManager);
+                        themeManager.themeChanged.connect(updateColorMode);
+                        return () => {
+                            themeManager.themeChanged.disconnect(updateColorMode);
+                        };
+                    }
+                }
+                catch (e) {
+                    console.error('Error while setting the theme', e);
+                }
+            }
+            else {
+                colorSchemeFromMedia({
+                    matches: window.matchMedia('(prefers-color-scheme: dark)').matches
+                });
+                window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', colorSchemeFromMedia);
+                return () => {
+                    window.matchMedia('(prefers-color-scheme: dark)').removeEventListener('change', colorSchemeFromMedia);
+                };
+            }
+        }
+    }, [inJupyterLab, jupyterLabAdapter]);
+    return (inJupyterLab !== undefined ?
+        _jsx(PrimerThemeProvider, { colorMode: colorMode, theme: inJupyterLab ? jupyterLabTheme : datalayerTheme, ...rest, children: _jsx(BaseStyles, { style: {
+                    backgroundColor: 'var(--bgColor-default)',
+                    color: 'var(--fgColor-default)',
+                    fontSize: 'var(--text-body-size-medium)',
+                    ...baseStyles
+                }, children: children }) })
+        :
+            _jsx(_Fragment, {}));
+}

package/lib/theme/Palette.d.ts

@@ -0,0 +1,5 @@
+export declare const jpCssToColor: (cssVariableName: string) => any;
+export declare const RESERVATION_CIRCLE_COLOR = "#656D76";
+export declare const CREDITS_CIRCLE_COLOR = "#16A085";
+export declare const JOINED_INVITE_COLOR = "#0366d6";
+export declare const PENDING_INVITE_COLOR = "#cfd3d7";

package/lib/theme/Palette.js

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+const JUPYTERLAB_COLLABORATORS_COLORS = {
+    '--jp-collaborator-color1': '#ffad8e',
+    '--jp-collaborator-color2': '#dac83d',
+    '--jp-collaborator-color3': '#72dd76',
+    '--jp-collaborator-color4': '#00e4d0',
+    '--jp-collaborator-color5': '#45d4ff',
+    '--jp-collaborator-color6': '#e2b1ff',
+    '--jp-collaborator-color7': '#ff9de6'
+};
+export const jpCssToColor = (cssVariableName) => {
+    return JUPYTERLAB_COLLABORATORS_COLORS[cssVariableName.replaceAll('var(', '').replaceAll(')', '')];
+};
+// export const RESERVATION_CIRCLE_COLOR_VAR = '--data-yellow-color';
+export const RESERVATION_CIRCLE_COLOR = '#656D76';
+// export const CREDITS_CIRCLE_COLOR_VAR = '--data-blue-color';
+export const CREDITS_CIRCLE_COLOR = '#16A085';
+export const JOINED_INVITE_COLOR = '#0366d6';
+export const PENDING_INVITE_COLOR = '#cfd3d7';

package/lib/theme/index.d.ts

@@ -0,0 +1,3 @@
+export * from './DatalayerTheme';
+export * from './DatalayerThemeProvider';
+export * from './Palette';

package/lib/theme/index.js

@@ -0,0 +1,12 @@
+/*
+ * 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 './DatalayerTheme';
+export * from './DatalayerThemeProvider';
+export * from './Palette';