@datalayer/core 0.0.1 → 0.0.3

package/lib/state/storage/IAMStorage.js

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD 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,5 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD 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,40 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD 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,21 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD 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,88 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD 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,16 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD 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,14 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD 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,14 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD 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> | object;
+    /**
+     * 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;