@datalayer/core 1.2.10 → 1.2.13

package/lib/hooks/useNavigate.js

@@ -14,10 +14,17 @@
  * `window.open` otherwise, so a button gets it too. `newTab` in the options
  * opens a new tab outright.
  *
+ * Every navigation that stays in this tab is also **recorded** against the
+ * shell the reader is in ({@link state/substates/NavigationState}). That is
+ * what lets a reader switch from Agentify back to Home and find the page they
+ * left rather than a landing page, and it is done here — the one place every
+ * navigation goes through — rather than in an effect per layout.
+ *
  * @module hooks/useNavigate
  */
 import { useCallback, useMemo } from 'react';
 import { useLayoutStore } from '../state/index.js';
+import { navigationStore } from '../state/substates/NavigationState.js';
 import { createNativeNavigate } from '../navigation/adapters/native.js';
 // Import React Router hooks from our wrapper
 import { useNavigateRR } from '../navigation/adapters/react-router.js';
@@ -125,6 +132,9 @@ export const useNavigate = () => {
             window.scrollTo(0, 0);
             document.body.scrollTop = 0;
         }
+        // Where the reader is now, for the shell they are in. A new tab and a
+        // step back through history are both already past by here.
+        navigationStore.getState().rememberRoute(to);
         if (rrNavigate) {
             rrNavigate(to, { replace: options.replace, state: options.state });
             return;

package/lib/hooks/useWindowSize.js

@@ -50,7 +50,7 @@ export function useWindowSize() {
     return windowSize;
 }
 const breakpointSwitch = (value) => {
-    let current = BreakpointSize.XXLARGE;
+    let current;
     switch (true) {
         case value >= 320 && value < 544:
             current = BreakpointSize.XSMALL;

package/lib/models/IAMProvidersSpecs.d.ts

@@ -1,9 +1,15 @@
 import { IUser } from './User';
 export type IIAMProviderName = 'bluesky' | 'discord' | 'github' | 'google' | 'linkedin' | 'okta' | 'x';
+/** Providers whose access token is intentionally available to browser code. */
+export type IBrowserTokenProviderName = Exclude<IIAMProviderName, 'bluesky' | 'linkedin'>;
 export type IIAMProviderSpec = {
     name: IIAMProviderName;
     oauth2CallbackServerRoute: string;
     oauth2CallbackUIRoute: string;
+};
+/** Provider metadata used only when its access token may be read by the UI. */
+export type IBrowserTokenProviderSpec = IIAMProviderSpec & {
+    name: IBrowserTokenProviderName;
     accessTokenCookieName: (user: IUser) => string;
     refreshTokenCookieName: string;
     userInfoURL: string;
@@ -13,11 +19,10 @@ export type IIAMProviderSpec = {
 };
 export declare class IAMProvidersSpecs {
     private constructor();
-    static getProvider(providerIAMProvidersType: any): IIAMProviderSpec;
-    static readonly Bluesky: IIAMProviderSpec;
-    static readonly GitHub: IIAMProviderSpec;
-    static readonly Google: IIAMProviderSpec;
+    static getProvider(providerIAMProvidersType: IBrowserTokenProviderName): IBrowserTokenProviderSpec;
+    static readonly GitHub: IBrowserTokenProviderSpec;
+    static readonly Google: IBrowserTokenProviderSpec;
     static readonly LinkedIn: IIAMProviderSpec;
-    static readonly Okta: IIAMProviderSpec;
+    static readonly Okta: IBrowserTokenProviderSpec;
 }
 export default IAMProvidersSpecs;

package/lib/models/IAMProvidersSpecs.js

@@ -6,18 +6,12 @@ export class IAMProvidersSpecs {
     constructor() { }
     static getProvider(providerIAMProvidersType) {
         switch (providerIAMProvidersType) {
-            case 'bluesky': {
-                return this.Bluesky;
-            }
             case 'github': {
                 return this.GitHub;
             }
             case 'google': {
                 return this.Google;
             }
-            case 'linkedin': {
-                return this.LinkedIn;
-            }
             case 'okta': {
                 return this.Okta;
             }
@@ -27,17 +21,6 @@ export class IAMProvidersSpecs {
             }
         }
     }
-    static Bluesky = {
-        name: 'bluesky',
-        oauth2CallbackServerRoute: 'jupyter_iam/oauth2/callback',
-        oauth2CallbackUIRoute: '/iam/oauth2/bluesky/callback',
-        accessTokenCookieName: (user) => `__datalayer__bluesky_access_token_${user.id}`,
-        refreshTokenCookieName: '__datalayer__bluesky_refresh_token',
-        userInfoURL: '',
-        tokenRefreshURL: '',
-        postShareURL: '',
-        registerUploadURL: '',
-    };
     static GitHub = {
         name: 'github',
         oauth2CallbackServerRoute: 'jupyter_iam/oauth2/callback',
@@ -64,12 +47,6 @@ export class IAMProvidersSpecs {
         name: 'linkedin',
         oauth2CallbackServerRoute: 'jupyter_iam/oauth2/callback',
         oauth2CallbackUIRoute: '/iam/oauth2/linkedin/callback',
-        accessTokenCookieName: (user) => `__datalayer__linkedin_access_token_${user.id}`,
-        refreshTokenCookieName: '__datalayer__linkedin_refresh_token',
-        userInfoURL: 'https://api.linkedin.com/v2/userinfo',
-        tokenRefreshURL: '',
-        postShareURL: 'https://api.linkedin.com/v2/ugcPosts',
-        registerUploadURL: 'https://api.linkedin.com/v2/assets?action=registerUpload',
     };
     static Okta = {
         name: 'okta',

package/lib/models/URN.d.ts

@@ -1,3 +1,6 @@
+import type { IIAMProviderName } from './IAMProvidersSpecs';
+/** What an identity provider's account URN starts with, before its name. */
+export declare const IAM_PROVIDER_URN_PREFIX = "urn:dla:iam:ext::";
 export declare class URN implements IURN {
     private _partition;
     private _service;
@@ -12,7 +15,41 @@ export declare class URN implements IURN {
     get account(): string;
     get type(): string;
     get uid(): string;
+    /** An identity provider's account (`urn:dla:iam:ext::github:…`). */
+    get isIAMProviderAccount(): boolean;
+    toString(): string;
 }
+/** A URN, or `undefined` when the value is not one — never a throw. */
+export declare function parseURN(value?: string | null): URN | undefined;
+/**
+ * Where an account came from, read from its `origin`.
+ *
+ * - `datalayer`: made on Datalayer, with a password.
+ * - `iam-provider`: made by signing in with an identity provider, which it
+ *   still signs in through (`urn:dla:iam:ext::<provider>:<account id>`).
+ * - `urn`: any other URN — an AWS Marketplace or enterprise origin.
+ * - `unknown`: nothing recorded, or a value that is none of the above.
+ */
+export type IAccountOrigin = {
+    kind: 'datalayer';
+} | {
+    kind: 'iam-provider';
+    provider: IIAMProviderName;
+    accountId: string;
+    urn: URN;
+} | {
+    kind: 'urn';
+    urn: URN;
+} | {
+    kind: 'unknown';
+    value: string;
+};
+export declare function accountOriginOf(origin?: string | null): IAccountOrigin;
+/**
+ * Whether an account signs in through a provider: disconnecting that
+ * provider would leave it nothing to sign in with.
+ */
+export declare function signsInWith(origin: string | null | undefined, provider: IIAMProviderName): boolean;
 /**
   Datalayer Uniform Resource Name (URN)
 

package/lib/models/URN.js

@@ -2,6 +2,8 @@
  * Copyright (c) 2023-2025 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
+/** What an identity provider's account URN starts with, before its name. */
+export const IAM_PROVIDER_URN_PREFIX = 'urn:dla:iam:ext::';
 export class URN {
     _partition;
     _service;
@@ -17,7 +19,8 @@ export class URN {
         this._region = parts[3];
         this._account = parts[4];
         this._type = parts[5];
-        this._uid = parts[6];
+        // The rest, colons and all: a provider's account id may carry them.
+        this._uid = parts.slice(6).join(':');
     }
     get partition() {
         return this._partition;
@@ -37,4 +40,59 @@ export class URN {
     get uid() {
         return this._uid;
     }
+    /** An identity provider's account (`urn:dla:iam:ext::github:…`). */
+    get isIAMProviderAccount() {
+        return this._service === 'iam' && this._region === 'ext' && !!this._type;
+    }
+    toString() {
+        return [
+            'urn',
+            this._partition,
+            this._service,
+            this._region,
+            this._account,
+            this._type,
+            this._uid,
+        ].join(':');
+    }
+}
+/** A URN, or `undefined` when the value is not one — never a throw. */
+export function parseURN(value) {
+    const text = (value ?? '').trim();
+    if (!text.toLowerCase().startsWith('urn:') || text.split(':').length < 7) {
+        return undefined;
+    }
+    return new URN(text);
+}
+const IAM_PROVIDER_NAMES = [
+    'bluesky',
+    'discord',
+    'github',
+    'google',
+    'linkedin',
+    'okta',
+    'x',
+];
+export function accountOriginOf(origin) {
+    const value = (origin ?? '').trim();
+    if (value === 'datalayer') {
+        return { kind: 'datalayer' };
+    }
+    const urn = parseURN(value);
+    if (!urn) {
+        return { kind: 'unknown', value };
+    }
+    const provider = urn.type.toLowerCase();
+    if (urn.isIAMProviderAccount && IAM_PROVIDER_NAMES.includes(provider)) {
+        return { kind: 'iam-provider', provider, accountId: urn.uid, urn };
+    }
+    return { kind: 'urn', urn };
+}
+/**
+ * Whether an account signs in through a provider: disconnecting that
+ * provider would leave it nothing to sign in with.
+ */
+export function signsInWith(origin, provider) {
+    const parsed = accountOriginOf(origin);
+    return parsed.kind === 'iam-provider' && parsed.provider === provider;
 }

package/lib/navigation/adapters/react-router.d.ts

@@ -1,4 +1,4 @@
 import * as ReactRouterDom from 'react-router-dom';
 export declare const useParamsRR: typeof ReactRouterDom.useParams;
 export declare const useLocationRR: typeof ReactRouterDom.useLocation;
-export declare const useNavigateRR: typeof ReactRouterDom.useNavigate;
+export declare const useNavigateRR: () => ReactRouterDom.NavigateFunction;

package/lib/navigation/adapters/react-router.js

@@ -9,4 +9,7 @@ import * as ReactRouterDom from 'react-router-dom';
 // Export hooks for use in our navigation hooks
 export const useParamsRR = ReactRouterDom.useParams;
 export const useLocationRR = ReactRouterDom.useLocation;
+// Typed here rather than inferred: the inferred type carries React Router's
+// own doc comment, whose links (`redirect`, `To`, `<ScrollRestoration>`) point
+// at symbols these docs do not include, and typedoc fails the build on them.
 export const useNavigateRR = ReactRouterDom.useNavigate;

package/lib/state/sessionEnd.js

@@ -142,7 +142,7 @@ export const claimSessionState = (userUid) => {
         return;
     }
     const localStorage = storageOf('localStorage');
-    let owner = null;
+    let owner;
     try {
         owner = localStorage?.getItem(SESSION_OWNER_KEY) ?? null;
     }

package/lib/state/substates/CoreState.js

@@ -4,6 +4,7 @@
  */
 import { createStore } from 'zustand/vanilla';
 import { useStore } from 'zustand';
+import { DEFAULT_PLANE_URLS } from '../../config/planes.js';
 import { configLogger } from '../../utils/Logger.js';
 let loadConfigurationFromServer = true;
 let initialConfiguration = {
@@ -15,22 +16,8 @@ let initialConfiguration = {
     whiteLabel: true,
     loadConfigurationFromServer: true,
     jupyterServerless: false,
-    iamUrl: 'https://prod1.datalayer.run',
-    contentsUrl: 'https://r1.datalayer.run',
-    managerUrl: 'https://prod1.datalayer.run',
-    runtimesUrl: 'https://r1.datalayer.run',
-    schedulerUrl: 'https://r1.datalayer.run',
-    libraryUrl: 'https://prod1.datalayer.run',
-    spacerUrl: 'https://prod1.datalayer.run',
-    aiAgentsUrl: 'https://r1.datalayer.run',
-    aiInferenceUrl: 'https://r1.datalayer.run',
-    jupyterMcpServerUrl: 'https://mcp.datalayer.run/mcp',
-    otelUrl: 'https://prod1.datalayer.run',
-    // Defaults to prod so telemetry is consumed from the production OTEL service
-    growthUrl: 'https://prod1.datalayer.run',
-    inboundsUrl: 'https://prod1.datalayer.run',
-    successUrl: 'https://prod1.datalayer.run',
-    supportUrl: 'https://prod1.datalayer.run',
+    // Which plane each service is on is said once, in `config/planes`.
+    ...DEFAULT_PLANE_URLS,
     launcher: {
         category: 'Datalayer',
         name: 'Datalayer',

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

@@ -1,4 +1,4 @@
-import { IUser, IIAMProviderName } from '../../models';
+import { IUser, IIAMProviderName, IBrowserTokenProviderName } from '../../models';
 import type { ICredits, ICreditsReservation } from '../../models';
 /**
  * Limit to warn about low credits in milliseconds.
@@ -55,8 +55,8 @@ export type IAMState = IIAMState & {
      */
     refreshCredits: () => Promise<void>;
     checkIAMToken: (token: string) => Promise<void>;
-    setIAMProviderAccessToken: (provider: IIAMProviderName, accessToken?: string | null) => void;
-    getIAMProviderAccessToken: (user: IUser, provider: IIAMProviderName) => string | undefined;
+    setIAMProviderAccessToken: (provider: IBrowserTokenProviderName, accessToken?: string | null) => void;
+    getIAMProviderAccessToken: (user: IUser, provider: IBrowserTokenProviderName) => string | undefined;
     refreshUser: () => Promise<void>;
     refreshUserByTokenStored: () => Promise<void>;
     refreshUserByToken: (token: string) => Promise<void>;

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

@@ -0,0 +1,92 @@
+/** The signed-in shell: the platform, the business cases, or the admin. */
+/**
+ * The four shells of the signed-in application.
+ *
+ * `studio` is where an agentic UI application is composed, validated and
+ * shipped — the default for somebody who has not chosen, and what the root
+ * shows. `home` is the whole platform, shown as *Power*, at `/power`: the key
+ * is kept so a cookie written before the Studio existed still names the
+ * shell it meant. `agentify` is the business cases; `admin` is the
+ * platform's administration.
+ */
+export type NavigationView = 'studio' | 'home' | 'agentify' | 'admin';
+/** The shells, and where each one opens when it has not been visited. */
+export declare const NAVIGATION_VIEW_HOMES: Record<NavigationView, string>;
+/** Well-known view identifiers for {@link NavigationState.tabsByView}. */
+export declare const LIBRARY_VIEW = "library";
+export declare const AGENTS_VIEW = "agents";
+export declare const SETTINGS_VIEW = "settings";
+export declare const DATALAYER_VIEW = "datalayer";
+export declare const CONTENTS_VIEW = "contents";
+export declare const TUTOR_VIEW = "tutor";
+export type NavigationState = {
+    /** The shell the reader last chose. */
+    view: NavigationView;
+    /** State which shell is being shown. */
+    setView: (view: NavigationView) => void;
+    /** Swap the platform and the business cases. */
+    toggleView: () => void;
+    /** The page each shell was last on. */
+    lastRouteByView: Partial<Record<NavigationView, string>>;
+    /**
+     * Remember a page as the current shell's, or as another's when told.
+     *
+     * Called by {@link useNavigate} for every navigation, which is what makes
+     * this the one place the answer comes from.
+     */
+    rememberRoute: (route: string, view?: NavigationView) => void;
+    /** Where a shell was left, or where it opens when it never was. */
+    routeForView: (view: NavigationView) => string;
+    /** Last selected tab, by view identifier. */
+    tabsByView: Record<string, string>;
+    /** Keep the tab a view was left on. */
+    setViewTab: (view: string, tab: string) => void;
+    /** The tab a view was left on, if any. */
+    getViewTab: (view: string) => string | undefined;
+    /**
+     * The route a signed-out reader asked for, to resume after signing in.
+     *
+     * Never persisted: a reload must land on the default route, and the OAuth
+     * round trip carries its target in `post_auth_redirect` instead.
+     */
+    requestedRoute?: string;
+    setRequestedRoute: (route: string) => void;
+    clearRequestedRoute: () => void;
+    /** The address the reader was on before the documentation. */
+    docsOrigin?: string;
+    setDocsOrigin: (origin: string) => void;
+};
+/**
+ * Whether a page is worth remembering as a shell's.
+ *
+ * Not the sign-in pages, the OAuth callbacks or the documentation: coming
+ * back to a shell should land on the work, not on the door the reader came
+ * through or on a page that belongs to no shell.
+ */
+export declare function isRememberableRoute(route: string): boolean;
+/**
+ * The shell a route belongs to, read off its first segment.
+ *
+ * The store used to trust whatever `view` said when a route was recorded,
+ * and `view` was only ever written by the header toggle. A reader who
+ * reached Home through a sidebar link while the toggle still said Agentify
+ * had their Home pages filed under Agentify — and the toggle, seeing
+ * "Agentify" already chosen, did nothing when they clicked it.
+ */
+export declare function viewForRoute(route: string): NavigationView;
+export declare const navigationStore: import("zustand").StoreApi<NavigationState>;
+/**
+ * The hook, shaped like a `zustand` store created with `create`: callable
+ * with or without a selector, and carrying `getState`, `setState` and
+ * `subscribe` for the callers — a router guard, a test — that read it outside
+ * a render.
+ */
+export interface UseNavigationStore {
+    (): NavigationState;
+    <T>(selector: (state: NavigationState) => T): T;
+    getState: () => NavigationState;
+    setState: typeof navigationStore.setState;
+    subscribe: typeof navigationStore.subscribe;
+}
+export declare const useNavigationStore: UseNavigationStore;
+export default useNavigationStore;