@datalayer/core 0.0.1 → 0.0.2

package/lib/routes/Routes.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 const CONTACT_ROUTE = 'contact';
+export const SUPPORT_ROUTE = 'support';
+export const USAGE_ROUTE = 'usage';

package/lib/routes/index.d.ts

@@ -0,0 +1 @@
+export * from "./Routes";

package/lib/routes/index.js

@@ -0,0 +1,10 @@
+/*
+ * 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 "./Routes";

package/lib/state/State.d.ts

@@ -0,0 +1,33 @@
+import { coreStore } from './substates/CoreState';
+import { cellStore } from './substates/CellState';
+import { documentStore } from './substates/DocumentState';
+import { gradeStore } from './substates/GradeState';
+import { iamStore } from './substates/IAMState';
+import { runtimesStore } from './substates/RuntimesState';
+import { layoutStore } from './substates/LayoutState';
+import { nbformatStore } from './substates/NbformatState';
+import { organizationStore } from './substates/OrganizationState';
+import { spaceStore } from './substates/SpaceState';
+import { surveysStore } from './substates/SurveysState';
+import { teamStore } from './substates/TeamState';
+export type DatalayerRunState = {
+    version: string;
+    setVersion: (version: string) => void;
+    isDev: boolean;
+    core: typeof coreStore.getState;
+    cell: typeof cellStore.getState;
+    document: typeof documentStore.getState;
+    grade: typeof gradeStore.getState;
+    iam: typeof iamStore.getState;
+    kernels: typeof runtimesStore.getState;
+    layout: typeof layoutStore.getState;
+    nbformat: typeof nbformatStore.getState;
+    organization: typeof organizationStore.getState;
+    space: typeof spaceStore.getState;
+    success: typeof surveysStore.getState;
+    team: typeof teamStore.getState;
+};
+export declare const runStore: import("zustand").StoreApi<DatalayerRunState>;
+export declare function useRunStore(): DatalayerRunState;
+export declare function useRunStore<T>(selector: (state: DatalayerRunState) => T): T;
+export default useRunStore;

package/lib/state/State.js

@@ -0,0 +1,49 @@
+/*
+ * 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 { coreStore } from './substates/CoreState';
+import { cellStore } from './substates/CellState';
+import { documentStore } from './substates/DocumentState';
+import { gradeStore } from './substates/GradeState';
+import { iamStore } from './substates/IAMState';
+import { runtimesStore } from './substates/RuntimesState';
+import { layoutStore } from './substates/LayoutState';
+import { nbformatStore } from './substates/NbformatState';
+import { organizationStore } from './substates/OrganizationState';
+import { spaceStore } from './substates/SpaceState';
+import { surveysStore } from './substates/SurveysState';
+import { teamStore } from './substates/TeamState';
+import { isDevDeployment } from '../utils';
+export const runStore = createStore((set, get) => ({
+    version: '',
+    setVersion: version => {
+        if (version && !get().version) {
+            set(state => ({ version }));
+        }
+    },
+    isDev: isDevDeployment(),
+    core: coreStore.getState,
+    cell: cellStore.getState,
+    document: documentStore.getState,
+    grade: gradeStore.getState,
+    iam: iamStore.getState,
+    kernels: runtimesStore.getState,
+    layout: layoutStore.getState,
+    nbformat: nbformatStore.getState,
+    organization: organizationStore.getState,
+    space: spaceStore.getState,
+    success: surveysStore.getState,
+    team: teamStore.getState,
+}));
+export function useRunStore(selector) {
+    return useStore(runStore, selector);
+}
+export default useRunStore;

package/lib/state/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./storage";
+export * from './State';
+export * from './substates';

package/lib/state/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 "./storage";
+export * from './State';
+export * from './substates';

package/lib/state/storage/IAMStorage.d.ts

@@ -0,0 +1,33 @@
+import { IUser } from '../../models';
+export declare const JWT_DATALAYER_ISSUER = "https://id.datalayer.run";
+export declare const DATALAYER_IAM_USER_KEY = "@datalayer/iam:user";
+export declare const DATALAYER_IAM_TOKEN_KEY = "@datalayer/iam:token";
+export declare const JWT_REFRESH_TOKEN_COOKIE_NAME = "refresh_token";
+export type IJWTToken = {
+    exp: number;
+    iat: number;
+    iss: string;
+    jti: number;
+    roles: Array<string>;
+    sub: IUser;
+};
+/**
+ * Return the user from the local storage.
+ */
+export declare const getStoredUser: () => IUser | undefined;
+/**
+ * Set the user in the local storage.
+ */
+export declare const storeUser: (user?: IUser) => void;
+/**
+ * Return the IAM token from the local storage.
+ */
+export declare const getStoredToken: () => string | undefined;
+/**
+ * Set the IAM token in the local storage.
+ */
+export declare const storeToken: (token?: string) => void;
+/**
+ * Load a JWT refresh token stored in a cookie.
+ */
+export declare function loadRefreshTokenFromCookie(): string | undefined;

package/lib/state/storage/IAMStorage.js

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+import jwt_decode from 'jwt-decode';
+import { getCookie } from '../../utils';
+import { ANONYMOUS_USER, ANONYMOUS_USER_TOKEN } from '../../models';
+export const JWT_DATALAYER_ISSUER = 'https://id.datalayer.run';
+export const DATALAYER_IAM_USER_KEY = '@datalayer/iam:user';
+export const DATALAYER_IAM_TOKEN_KEY = '@datalayer/iam:token';
+export const JWT_REFRESH_TOKEN_COOKIE_NAME = 'refresh_token';
+/**
+ * Return the user from the local storage.
+ */
+export const getStoredUser = () => {
+    const user = window.localStorage.getItem(DATALAYER_IAM_USER_KEY);
+    if (user) {
+        try {
+            const u = JSON.parse(user);
+            u.joinDate = new Date(u.joinDate);
+            return u;
+        }
+        catch (e) {
+            return ANONYMOUS_USER;
+        }
+    }
+    return ANONYMOUS_USER;
+};
+/**
+ * Set the user in the local storage.
+ */
+export const storeUser = (user) => {
+    if (user) {
+        window.localStorage.setItem(DATALAYER_IAM_USER_KEY, JSON.stringify(user));
+    }
+    else {
+        window.localStorage.removeItem(DATALAYER_IAM_USER_KEY);
+    }
+};
+/**
+ * Return the IAM token from the local storage.
+ */
+export const getStoredToken = () => {
+    const token = window.localStorage.getItem(DATALAYER_IAM_TOKEN_KEY);
+    if (token) {
+        return token;
+    }
+    return ANONYMOUS_USER_TOKEN;
+};
+/**
+ * Set the IAM token in the local storage.
+ */
+export const storeToken = (token) => {
+    if (token) {
+        if (token !== ANONYMOUS_USER_TOKEN) {
+            try {
+                const jwt = jwt_decode(token);
+                console.debug('JWT Token', jwt);
+            }
+            catch (error) {
+                console.error("Error while decoding JWT Token.", error);
+                throw error;
+            }
+        }
+        localStorage.setItem(DATALAYER_IAM_TOKEN_KEY, token);
+    }
+    else {
+        window.localStorage.removeItem(DATALAYER_IAM_TOKEN_KEY);
+    }
+};
+/**
+ * Load a JWT refresh token stored in a cookie.
+ */
+export function loadRefreshTokenFromCookie() {
+    return getCookie(JWT_REFRESH_TOKEN_COOKIE_NAME);
+}

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

@@ -0,0 +1 @@
+export * from "./IAMStorage";

package/lib/state/storage/index.js

@@ -0,0 +1,10 @@
+/*
+ * 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 "./IAMStorage";

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

@@ -0,0 +1,11 @@
+import type { IAIAgent } from '../../models';
+export type AIAgentState = {
+    aiAgents: readonly IAIAgent[];
+    addAIAgent: (aiAgent: IAIAgent) => void;
+    deleteAIAgent: (documentId: string) => void;
+    updateAIAgent: (documentId: string, runtimeId?: string) => void;
+};
+export declare const aiAgentStore: import("zustand").StoreApi<AIAgentState>;
+export declare function useAIAgentStore(): AIAgentState;
+export declare function useAIAgentStore<T>(selector: (state: AIAgentState) => T): T;
+export default useAIAgentStore;

package/lib/state/substates/AIAgentState.js

@@ -0,0 +1,45 @@
+/*
+ * 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 aiAgentStore = createStore(set => ({
+    aiAgents: [],
+    addAIAgent: (aiAgent) => {
+        set((state) => {
+            if (!state.aiAgents.includes(aiAgent)) {
+                return { aiAgents: state.aiAgents.concat([aiAgent]) };
+            }
+            else {
+                return {};
+            }
+        });
+    },
+    deleteAIAgent: (documentId) => {
+        set((state) => {
+            return { aiAgents: state.aiAgents.filter(a => a.documentId === documentId) };
+        });
+    },
+    updateAIAgent: (documentId, runtimeId) => {
+        set((state) => {
+            const index = state.aiAgents.findIndex(aiAgent => aiAgent.documentId === documentId);
+            if (index >= 0) {
+                state.aiAgents[index].runtimeId = runtimeId;
+                return { aiAgents: [...state.aiAgents] };
+            }
+            else {
+                return {};
+            }
+        });
+    }
+}));
+export function useAIAgentStore(selector) {
+    return useStore(aiAgentStore, selector);
+}
+export default useAIAgentStore;

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

@@ -0,0 +1,12 @@
+import { ICell } from '../../models';
+export type ICellState = {
+    cell?: ICell;
+};
+export type CellState = ICellState & {
+    create: (cell: ICell) => void;
+    update: (cell: Partial<ICell>) => void;
+};
+export declare const cellStore: import("zustand").StoreApi<CellState>;
+export declare function useCellStore(): CellState;
+export declare function useCellStore<T>(selector: (state: CellState) => T): T;
+export default useCellStore;

package/lib/state/substates/CellState.js

@@ -0,0 +1,26 @@
+/*
+ * 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 cellStore = createStore((set, get) => ({
+    cell: undefined,
+    create: (cell) => set((state) => ({ cell })),
+    update: (cell) => set((state) => ({
+        cell: cell ? {
+            ...state.cell,
+            ...cell,
+        }
+            : undefined
+    })),
+}));
+export function useCellStore(selector) {
+    return useStore(cellStore, selector);
+}
+export default useCellStore;

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

@@ -0,0 +1,25 @@
+import type { IDatalayerCoreConfig } from '../../config';
+export type DatalayerCoreState = {
+    tab: number;
+    getIntTab: () => number;
+    setTab: (tab: number) => void;
+    /**
+     * Datalayer configuration
+     */
+    configuration: IDatalayerCoreConfig;
+    /**
+     * Set the Datalayer configuration
+     */
+    setConfiguration: (configuration: Partial<IDatalayerCoreConfig>) => void;
+    /**
+     * Package version
+     */
+    version: string;
+    setVersion: (version: string) => void;
+    loadConfigurationFromServer: boolean;
+    setLoadConfigurationFromServer: (loadConfigurationFromServer: boolean) => void;
+};
+export declare const coreStore: import("zustand").StoreApi<DatalayerCoreState>;
+export declare function useCoreStore(): DatalayerCoreState;
+export declare function useCoreStore<T>(selector: (state: DatalayerCoreState) => T): T;
+export default useCoreStore;

package/lib/state/substates/CoreState.js

@@ -0,0 +1,93 @@
+/*
+ * 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';
+let loadConfigurationFromServer = true;
+let initialConfiguration = {
+    useMock: false,
+    whiteLabel: true,
+    loadConfigurationFromServer: true,
+    jupyterServerless: false,
+    iamRunUrl: 'https://prod1.datalayer.run',
+    runtimesRunUrl: 'https://prod1.datalayer.run',
+    libraryRunUrl: 'https://prod1.datalayer.run',
+    spacerRunUrl: 'https://prod1.datalayer.run',
+    aiagentsRunUrl: 'https://prod1.datalayer.run',
+    growthRunUrl: 'https://prod1.datalayer.run',
+    inboundsRunUrl: 'https://prod1.datalayer.run',
+    successRunUrl: 'https://prod1.datalayer.run',
+    supportRunUrl: 'https://prod1.datalayer.run',
+    launcher: {
+        category: 'Datalayer',
+        name: 'Datalayer Runtimes',
+        icon: 'https://raw.githubusercontent.com/datalayer/icons/main/svg/data1/jupyter-base.svg',
+        rank: 1
+    },
+    brand: {
+        name: 'Datalayer',
+        about: 'AI Platform for Data Analysis',
+        logoUrl: 'https://assets.datalayer.tech/datalayer-25.svg',
+        logoSquareUrl: 'https://assets.datalayer.tech/datalayer-square.png',
+        copyright: '© 2025 Datalayer, Inc',
+        docsUrl: 'https://docs.datalayer.app',
+        supportUrl: 'https://datalayer.app/support',
+        termsUrl: 'https://datalayer.app/terms',
+        pricingUrl: 'https://datalayer.app/pricing',
+        privacyUrl: 'https://datalayer.app/privacy',
+    }
+};
+// Try loading initial state from datalayer-config-data element
+try {
+    const rawConfig = document.getElementById('datalayer-config-data');
+    if (rawConfig?.innerText) {
+        const htmlOverridingConfiguration = JSON.parse(rawConfig?.innerText || '{}');
+        if (htmlOverridingConfiguration.loadConfigurationFromServer != undefined) {
+            loadConfigurationFromServer = htmlOverridingConfiguration.loadConfigurationFromServer;
+        }
+        initialConfiguration = {
+            ...initialConfiguration,
+            ...htmlOverridingConfiguration,
+        };
+        console.log('Datalayer configuration loaded from HTML page', initialConfiguration);
+        window.document.title = `${initialConfiguration.brand.name} Ξ ${initialConfiguration.brand.about}`;
+    }
+}
+catch (error) {
+    console.debug('No valid configuration found in the webpage.', error);
+}
+export const coreStore = createStore((set, get) => ({
+    tab: 0.0,
+    getIntTab: () => Math.floor(get().tab),
+    setTab: (tab) => set((state) => ({ tab })),
+    configuration: initialConfiguration,
+    setConfiguration: (configuration) => {
+        console.log('Setting Datalayer configuration', configuration);
+        set(state => ({
+            configuration: {
+                ...state.configuration,
+                ...configuration
+            }
+        }));
+    },
+    version: '',
+    setVersion: version => {
+        if (version && !get().version) {
+            set(state => ({ version }));
+        }
+    },
+    loadConfigurationFromServer,
+    setLoadConfigurationFromServer: (loadConfigurationFromServer) => {
+        set(state => ({ loadConfigurationFromServer }));
+    },
+}));
+export function useCoreStore(selector) {
+    return useStore(coreStore, selector);
+}
+export default useCoreStore;

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

@@ -0,0 +1,11 @@
+import { IDatasource } from '../../models';
+export type IDatasourceState = {
+    datasources: IDatasource[];
+};
+export type DatasourceState = IDatasourceState & {
+    updateDatasources: (datasources: IDatasource[]) => void;
+};
+export declare const datasourceStore: import("zustand").StoreApi<DatasourceState>;
+export declare function useDatasourceStore(): DatasourceState;
+export declare function useDatasourceStore<T>(selector: (state: DatasourceState) => T): T;
+export default useDatasourceStore;

package/lib/state/substates/DatasourceState.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 datasourceStore = createStore((set, get) => ({
+    datasources: [],
+    updateDatasources: (datasources) => set((state) => ({
+        datasources
+    })),
+}));
+export function useDatasourceStore(selector) {
+    return useStore(datasourceStore, selector);
+}
+export default useDatasourceStore;

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

@@ -0,0 +1,10 @@
+export interface IDocumentState {
+    documentSaveRequest?: Date;
+}
+export type DocumentState = IDocumentState & {
+    save: (documentSaveRequest: Date) => void;
+};
+export declare const documentStore: import("zustand").StoreApi<DocumentState>;
+export declare function useDocumentStore(): DocumentState;
+export declare function useDocumentStore<T>(selector: (state: DocumentState) => T): T;
+export default useDocumentStore;

package/lib/state/substates/DocumentState.js

@@ -0,0 +1,19 @@
+/*
+ * 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 documentStore = createStore((set, get) => ({
+    documentSaveRequest: undefined,
+    save: (documentSaveRequest) => set((state) => ({ documentSaveRequest })),
+}));
+export function useDocumentStore(selector) {
+    return useStore(documentStore, selector);
+}
+export default useDocumentStore;

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

@@ -0,0 +1,10 @@
+export type IGradeState = {
+    gradeRequest?: Date;
+};
+export type GradeState = IGradeState & {
+    grade: (gradeRequest: Date) => void;
+};
+export declare const gradeStore: import("zustand").StoreApi<GradeState>;
+export declare function useGradeStore(): GradeState;
+export declare function useGradeStore<T>(selector: (state: GradeState) => T): T;
+export default useGradeStore;

package/lib/state/substates/GradeState.js

@@ -0,0 +1,19 @@
+/*
+ * 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 gradeStore = createStore((set, get) => ({
+    gradeRequest: undefined,
+    grade: (gradeRequest) => set((state) => ({ gradeRequest })),
+}));
+export function useGradeStore(selector) {
+    return useStore(gradeStore, selector);
+}
+export default useGradeStore;

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

@@ -0,0 +1,75 @@
+import { IUser, IIAMProviderName } from '../../models';
+import type { ICredits, ICreditsReservation } from '../../models';
+/**
+ * Limit to warn about low credits in milliseconds.
+ */
+export declare const RESERVATION_WARNING_TIME_MS: number;
+type IAMProviderAuthorizationURL = string;
+export type IIAMState = {
+    /**
+     * User credits
+     */
+    credits?: ICredits & {
+        available: number;
+    };
+    /**
+     * User credits reservations
+     */
+    creditsReservations: ICreditsReservation[];
+    /**
+     * User token for the external infrastructure
+     */
+    externalToken?: string;
+    /**
+     * IAM server base URL.
+     */
+    iamRunUrl: string;
+    /**
+     * Mapping of IAM providers and the corresponding Authorization URL.
+     */
+    iamProvidersAuthorizationURL: Record<IIAMProviderName, IAMProviderAuthorizationURL> | {};
+    /**
+     * User authenticated to Datalayer.
+     */
+    user?: IUser;
+    /**
+     * Authentication token
+     */
+    token?: string;
+    /**
+     * IAM service version
+     */
+    version: string;
+};
+export type IAMState = IIAMState & {
+    addIAMProviderAuthorizationURL: (provider: IIAMProviderName, authorizationURL: IAMProviderAuthorizationURL) => void;
+    login: (token: string) => Promise<void>;
+    logout: () => void;
+    /**
+     * Refresh user credits. It also warn if any
+     * reservation is getting close to the end.
+     */
+    refreshCredits: () => Promise<void>;
+    checkIAMToken: (token: string) => Promise<void>;
+    setIAMProviderAccessToken: (provider: IIAMProviderName, accessToken?: string | null) => void;
+    getIAMProviderAccessToken: (user: IUser, provider: IIAMProviderName) => string | undefined;
+    refreshUser: () => Promise<void>;
+    refreshUserByTokenStored: () => Promise<void>;
+    refreshUserByToken: (token: string) => Promise<void>;
+    setExternalToken: (externalToken: string) => void;
+    setVersion: (version: string) => void;
+    /**
+     * Set the {@link token} and the {@link user}.
+     *
+     * The user detail will be automatically retrieve
+     * to avoid inconsistency.
+     *
+     * @param token User token
+     */
+    setLogin: (user: IUser, token: string) => void;
+    updateUser: (user: Partial<Omit<IUser, 'handle'>>) => void;
+};
+export declare const iamStore: import("zustand").StoreApi<IAMState>;
+export declare function useIAMStore(): IAMState;
+export declare function useIAMStore<T>(selector: (state: IAMState) => T): T;
+export default useIAMStore;