@robosystems/core 0.3.0

package/auth-core/token-storage.js

@@ -0,0 +1,177 @@
+/**
+ * JWT Token Storage Management
+ *
+ * Provides secure storage for JWT tokens using localStorage
+ * for cross-domain authentication support and persistent sessions.
+ */
+const TOKEN_KEY = 'robosystems_jwt_token';
+const TOKEN_EXPIRY_KEY = 'robosystems_jwt_expiry';
+const TOKEN_THRESHOLD_KEY = 'robosystems_jwt_threshold';
+/**
+ * Store JWT token in localStorage
+ * @param token - The JWT token from login response
+ * @param expiresIn - Optional expiry time in seconds (default 30 minutes)
+ * @param refreshThreshold - Optional refresh threshold in seconds (default 5 minutes)
+ */
+export function storeToken(token, expiresIn = 1800, refreshThreshold = 300) {
+    // 30 minutes default to match backend token lifetime
+    if (typeof window === 'undefined')
+        return;
+    try {
+        const expiresAt = Date.now() + expiresIn * 1000;
+        localStorage.setItem(TOKEN_KEY, token);
+        localStorage.setItem(TOKEN_EXPIRY_KEY, expiresAt.toString());
+        localStorage.setItem(TOKEN_THRESHOLD_KEY, (refreshThreshold * 1000).toString());
+        // Log token storage for security monitoring
+        console.debug('[TokenStorage] Token stored with expiry:', new Date(expiresAt).toISOString(), 'Refresh threshold:', refreshThreshold, 'seconds');
+    }
+    catch (error) {
+        console.error('[TokenStorage] Failed to store token:', error);
+    }
+}
+/**
+ * Retrieve JWT token from localStorage
+ * @returns The stored token or null if not found/expired
+ */
+export function getToken() {
+    if (typeof window === 'undefined')
+        return null;
+    try {
+        const token = localStorage.getItem(TOKEN_KEY);
+        const expiryStr = localStorage.getItem(TOKEN_EXPIRY_KEY);
+        if (!token)
+            return null;
+        // Check if token is expired
+        if (expiryStr) {
+            const expiry = parseInt(expiryStr, 10);
+            if (Date.now() > expiry) {
+                clearToken();
+                return null;
+            }
+        }
+        return token;
+    }
+    catch (error) {
+        console.error('[TokenStorage] Failed to retrieve token:', error);
+        return null;
+    }
+}
+/**
+ * Clear JWT token from storage
+ */
+export function clearToken() {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        const hadToken = !!localStorage.getItem(TOKEN_KEY);
+        localStorage.removeItem(TOKEN_KEY);
+        localStorage.removeItem(TOKEN_EXPIRY_KEY);
+        localStorage.removeItem(TOKEN_THRESHOLD_KEY);
+        if (hadToken) {
+            logSecurityEvent('token_cleared', {
+                timestamp: new Date().toISOString(),
+                url: window.location.href,
+            });
+        }
+    }
+    catch (error) {
+        console.error('[TokenStorage] Failed to clear token:', error);
+    }
+}
+/**
+ * Get current token status
+ * @returns 'valid' if token is fresh, 'warning' if approaching expiry, 'expired' if expired
+ */
+export function getTokenStatus() {
+    if (typeof window === 'undefined')
+        return 'expired';
+    try {
+        const expiryStr = localStorage.getItem(TOKEN_EXPIRY_KEY);
+        const thresholdStr = localStorage.getItem(TOKEN_THRESHOLD_KEY);
+        if (!expiryStr)
+            return 'expired';
+        const expiry = parseInt(expiryStr, 10);
+        const threshold = thresholdStr ? parseInt(thresholdStr, 10) : 300000; // Default 5 min
+        const now = Date.now();
+        if (now > expiry)
+            return 'expired';
+        if (now > expiry - threshold)
+            return 'warning';
+        return 'valid';
+    }
+    catch (error) {
+        console.error('[TokenStorage] Failed to get token status:', error);
+        return 'expired';
+    }
+}
+/**
+ * Get time until token expiry in milliseconds
+ * @returns Time until expiry in ms, or 0 if expired
+ */
+export function getTimeUntilExpiry() {
+    if (typeof window === 'undefined')
+        return 0;
+    try {
+        const expiryStr = localStorage.getItem(TOKEN_EXPIRY_KEY);
+        if (!expiryStr)
+            return 0;
+        const expiry = parseInt(expiryStr, 10);
+        return Math.max(0, expiry - Date.now());
+    }
+    catch (error) {
+        console.error('[TokenStorage] Failed to get time until expiry:', error);
+        return 0;
+    }
+}
+/**
+ * Check if a valid token exists
+ * @returns True if a non-expired token exists
+ */
+export function hasValidToken() {
+    return getToken() !== null;
+}
+/**
+ * Get the Authorization header value for API requests
+ * @returns Bearer token header or null
+ */
+export function getAuthHeader() {
+    const token = getToken();
+    return token ? `Bearer ${token}` : null;
+}
+/**
+ * Extract token from login response and store it
+ * @param response - The auth response from login/refresh
+ */
+export function handleAuthResponse(response) {
+    if (response === null || response === void 0 ? void 0 : response.token) {
+        storeToken(response.token, response.expires_in || 1800, response.refresh_threshold || 300);
+    }
+}
+/**
+ * Get valid token (backend handles refresh via grace period)
+ * @returns Valid token or null if expired
+ */
+export async function getValidToken() {
+    const token = getToken();
+    if (!token)
+        return null;
+    // Just check if token is expired - let backend handle refresh
+    const expiryStr = localStorage.getItem(TOKEN_EXPIRY_KEY);
+    if (expiryStr) {
+        const expiry = parseInt(expiryStr, 10);
+        if (Date.now() > expiry) {
+            // Token is expired, clear it and let AuthProvider handle re-auth
+            clearToken();
+            return null;
+        }
+    }
+    return token;
+}
+/**
+ * Security event logging (for monitoring)
+ */
+function logSecurityEvent(event, details = {}) {
+    if (process.env.NODE_ENV === 'development') {
+        console.log(`[Security] ${event}:`, details);
+    }
+}

package/auth-core/types.d.ts

@@ -0,0 +1,145 @@
+export interface AuthUser {
+    id: string;
+    email: string;
+    name?: string;
+    emailVerified?: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface AuthResponse {
+    user: AuthUser;
+    success: boolean;
+    message?: string;
+    token?: string;
+    expires_in?: number;
+    refresh_threshold?: number;
+}
+export interface LoginRequest {
+    email: string;
+    password: string;
+}
+export interface RegisterRequest {
+    email: string;
+    password: string;
+    name?: string;
+}
+export interface APIKey {
+    id: string;
+    name: string;
+    key: string;
+    permissions: string[];
+    graphId?: string;
+    createdAt: string;
+    expiresAt?: string;
+    lastUsedAt?: string;
+    isActive: boolean;
+}
+export interface CreateAPIKeyRequest {
+    name: string;
+    permissions: string[];
+    graphId?: string;
+    expiresAt?: string;
+}
+export interface SSOTokenResponse {
+    token: string;
+    expires_at: string;
+    apps: string[];
+}
+export type AppName = 'robosystems' | 'roboledger' | 'roboinvestor';
+export interface AppConfig {
+    name: string;
+    displayName: string;
+    url: string;
+    description: string;
+    initials: string;
+    /**
+     * Literal Tailwind palette class for the app's brand (e.g. `bg-violet-600`).
+     * Uses literal palette colors — NOT `primary`/`secondary` tokens — so it
+     * renders the correct brand for any app even from inside another app.
+     */
+    colorClass: string;
+    /** The app's fixed brand hex — cross-app safe; drives the colored AnimatedLogo. */
+    brandColor: string;
+}
+export interface AuthContextType {
+    user: AuthUser | null;
+    isLoading: boolean;
+    isAuthenticated: boolean;
+    sessionWarning: {
+        show: boolean;
+        timeLeft: number;
+    };
+    login: (email: string, password: string) => Promise<AuthUser>;
+    register: (email: string, password: string, name?: string) => Promise<AuthUser>;
+    logout: () => Promise<void>;
+    refreshUser: () => Promise<AuthUser | null>;
+    refreshSession: (force?: boolean) => Promise<void>;
+    forgotPassword: (email: string) => Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    resetPassword: (token: string, newPassword: string) => Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    validateResetToken: (token: string) => Promise<{
+        valid: boolean;
+        email?: string;
+        message?: string;
+    }>;
+    verifyEmail: (token: string) => Promise<{
+        success: boolean;
+        message?: string;
+        user?: AuthUser;
+    }>;
+    resendVerificationEmail: (email: string) => Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+}
+export interface UseUserHook {
+    /**
+     * Refresh the current user's data from the server
+     */
+    refreshUser: () => Promise<AuthUser | null>;
+    /**
+     * Update the current user's profile information
+     */
+    updateProfile: (data: {
+        name?: string;
+        email?: string;
+    }) => Promise<AuthUser>;
+}
+export interface SDKAuthResponse {
+    user: AuthUser;
+    message?: string;
+    token?: string;
+    expires_in?: number | null;
+    refresh_threshold?: number | null;
+}
+export interface SDKCurrentUserResponse {
+    user: AuthUser;
+}
+export interface SDKApiKeyResponse {
+    api_key: {
+        id: string;
+        name: string;
+        created_at: string;
+        is_active: boolean;
+        last_used_at: string | null;
+    };
+    key: string;
+}
+export interface SDKApiKeysListResponse {
+    api_keys: Array<{
+        id: string;
+        name: string;
+        prefix: string;
+        created_at: string;
+        is_active: boolean;
+        last_used_at: string | null;
+    }>;
+}
+export interface SDKSsoExchangeResponse {
+    session_id: string;
+}

package/auth-core/types.js

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

package/components/EntitySelector.d.ts

@@ -0,0 +1,44 @@
+import React from 'react';
+export interface SelectableEntity {
+    id: string;
+    name: string;
+    subtitle?: string;
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+    metadata?: Record<string, any>;
+}
+export interface EntityGroup {
+    id: string;
+    name: string;
+    entities: SelectableEntity[];
+}
+export interface EntitySelectorProps<T extends SelectableEntity> {
+    entities: T[];
+    currentEntity?: T | null;
+    onEntityChange: (entity: T) => Promise<void>;
+    title: string;
+    placeholder?: string;
+    emptyStateMessage?: string;
+    emptyStateAction?: {
+        label: string;
+        href: string;
+    };
+    filter?: (entity: T) => boolean;
+    groupBy?: (entities: T[]) => EntityGroup[];
+    isLoading?: boolean;
+    isChanging?: boolean;
+    className?: string;
+    triggerClassName?: string;
+    defaultIcon?: React.ComponentType<{
+        className?: string;
+    }>;
+    additionalActions?: Array<{
+        label: string;
+        href: string;
+        icon?: React.ComponentType<{
+            className?: string;
+        }>;
+    }>;
+}
+export declare function EntitySelector<T extends SelectableEntity>({ entities, currentEntity, onEntityChange, title, placeholder, emptyStateMessage, emptyStateAction, filter, groupBy, isLoading, isChanging, className, triggerClassName, defaultIcon: DefaultIcon, additionalActions, }: EntitySelectorProps<T>): React.JSX.Element;

package/components/EntitySelector.js

@@ -0,0 +1,64 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Dropdown, DropdownItem, Spinner } from 'flowbite-react';
+import { useRouter } from 'next/navigation';
+import { useCallback, useState } from 'react';
+import { HiChevronDown } from 'react-icons/hi';
+import { useApiError, useToast } from '../hooks';
+export function EntitySelector({ entities, currentEntity, onEntityChange, title, placeholder = 'Select item', emptyStateMessage = 'No items available', emptyStateAction, filter, groupBy, isLoading = false, isChanging = false, className = '', triggerClassName = '', defaultIcon: DefaultIcon, additionalActions = [], }) {
+    const router = useRouter();
+    const { handleApiError } = useApiError();
+    const { showSuccess } = useToast();
+    const [switching, setSwitching] = useState(false);
+    // Filter entities if filter function is provided
+    const filteredEntities = filter ? entities.filter(filter) : entities;
+    // Group entities if groupBy function is provided
+    const entityGroups = groupBy ? groupBy(filteredEntities) : null;
+    const handleEntityChange = useCallback(async (entity) => {
+        if (entity.id === (currentEntity === null || currentEntity === void 0 ? void 0 : currentEntity.id) || switching)
+            return;
+        try {
+            setSwitching(true);
+            await onEntityChange(entity);
+            showSuccess(`Switched to ${entity.name}`);
+            router.refresh();
+        }
+        catch (error) {
+            handleApiError(error, `Failed to switch to ${entity.name}`);
+        }
+        finally {
+            setSwitching(false);
+        }
+    }, [
+        currentEntity,
+        switching,
+        onEntityChange,
+        showSuccess,
+        router,
+        handleApiError,
+    ]);
+    const isLoadingState = isLoading || isChanging || switching;
+    if (isLoadingState && !currentEntity && filteredEntities.length === 0) {
+        return (_jsxs("div", { className: "flex items-center gap-2 rounded-lg bg-gray-100 px-3 py-2 dark:bg-zinc-800", children: [_jsx(Spinner, { size: "sm" }), _jsxs("span", { className: "text-sm text-gray-500", children: ["Loading ", title.toLowerCase(), "..."] })] }));
+    }
+    // Empty state
+    if (!currentEntity && filteredEntities.length === 0) {
+        const EmptyIcon = emptyStateAction ? 'a' : 'div';
+        const emptyProps = emptyStateAction ? { href: emptyStateAction.href } : {};
+        return (_jsxs(EmptyIcon, Object.assign({}, emptyProps, { className: `flex items-center gap-2 rounded-lg bg-gray-100 px-3 py-2 text-sm font-medium text-gray-700 hover:bg-gray-200 dark:bg-zinc-800 dark:text-gray-300 dark:hover:bg-gray-700 ${emptyStateAction ? 'cursor-pointer' : ''}`, children: [DefaultIcon && _jsx(DefaultIcon, { className: "h-4 w-4" }), _jsx("span", { children: (emptyStateAction === null || emptyStateAction === void 0 ? void 0 : emptyStateAction.label) || emptyStateMessage })] })));
+    }
+    const displayEntity = currentEntity || filteredEntities[0];
+    const EntityIcon = (displayEntity === null || displayEntity === void 0 ? void 0 : displayEntity.icon) || DefaultIcon;
+    return (_jsx("div", { className: className, children: _jsx(Dropdown, { label: "", renderTrigger: () => (_jsxs("button", { className: `flex items-center gap-2 rounded-lg bg-gray-100 px-3 py-1.5 text-sm text-gray-700 hover:bg-gray-200 dark:bg-zinc-800 dark:text-white dark:hover:bg-zinc-700 ${triggerClassName}`, disabled: isLoadingState, children: [EntityIcon && _jsx(EntityIcon, { className: "h-4 w-4" }), _jsx("span", { className: "max-w-[150px] truncate", children: (displayEntity === null || displayEntity === void 0 ? void 0 : displayEntity.name) || placeholder }), isLoadingState ? (_jsx(Spinner, { size: "sm" })) : (_jsx(HiChevronDown, { className: `h-4 w-4 transition-transform` }))] })), children: filteredEntities.length === 0 ? (_jsx(_Fragment, { children: emptyStateAction && (_jsx(DropdownItem, { href: emptyStateAction.href, children: _jsxs("div", { className: "flex items-center gap-2", children: [DefaultIcon && _jsx(DefaultIcon, { className: "h-4 w-4" }), _jsx("span", { children: emptyStateAction.label })] }) })) })) : (_jsxs(_Fragment, { children: [entityGroups
+                        ? // Grouped entities
+                            entityGroups.map((group, groupIndex) => (_jsxs("div", { children: [groupIndex > 0 && (_jsx("div", { className: "border-t border-gray-200 dark:border-gray-600" })), _jsx("div", { className: "px-4 py-2 text-xs font-medium text-gray-500 uppercase dark:text-gray-400", children: group.name }), group.entities.map((entity) => (_jsx(EntityDropdownItem, { entity: entity, currentEntity: currentEntity, onEntityChange: handleEntityChange, isDisabled: isLoadingState }, entity.id)))] }, group.id)))
+                        : // Ungrouped entities
+                            filteredEntities.map((entity) => (_jsx(EntityDropdownItem, { entity: entity, currentEntity: currentEntity, onEntityChange: handleEntityChange, isDisabled: isLoadingState }, entity.id))), additionalActions.length > 0 && (_jsxs(_Fragment, { children: [_jsx("div", { className: "border-t border-gray-200 dark:border-gray-600" }), additionalActions.map((action, index) => (_jsx(DropdownItem, { href: action.href, children: _jsxs("div", { className: "flex items-center gap-2", children: [action.icon && _jsx(action.icon, { className: "h-4 w-4" }), _jsx("span", { children: action.label })] }) }, index)))] }))] })) }) }));
+}
+function EntityDropdownItem({ entity, currentEntity, onEntityChange, isDisabled, }) {
+    var _a;
+    const EntityIcon = entity.icon;
+    const isSelected = (currentEntity === null || currentEntity === void 0 ? void 0 : currentEntity.id) === entity.id;
+    const isRepository = ((_a = entity.metadata) === null || _a === void 0 ? void 0 : _a.isRepository) || false;
+    return (_jsx(DropdownItem, { onClick: () => onEntityChange(entity), disabled: isDisabled, className: `text-left ${isSelected ? 'bg-gray-200 dark:bg-gray-700/50' : ''}`, children: _jsxs("div", { className: "flex w-full items-center gap-3", children: [_jsx("div", { className: `flex h-8 w-8 shrink-0 items-center justify-center rounded-lg ${isRepository ? 'bg-secondary-600/20' : 'bg-primary-600/20'}`, children: EntityIcon && (_jsx(EntityIcon, { className: `h-4 w-4 ${isRepository ? 'text-secondary-400' : 'text-primary-400'}` })) }), _jsxs("div", { className: "min-w-0 flex-1 text-left", children: [_jsx("div", { className: "text-sm font-medium text-gray-900 dark:text-white", children: entity.name }), _jsx("div", { className: "truncate text-xs text-gray-500 dark:text-gray-400", children: entity.id.slice(0, 10) })] })] }) }));
+}

package/components/EntitySelectorCore.d.ts

@@ -0,0 +1,45 @@
+import React from 'react';
+import { type SelectableEntity } from './EntitySelector';
+export interface EntityLike {
+    identifier: string;
+    name: string;
+    [key: string]: any;
+}
+export interface GraphWithEntities {
+    graphId: string;
+    graphName: string;
+    entities: EntityLike[];
+    [key: string]: any;
+}
+export interface EntityRecord extends SelectableEntity {
+    entity: EntityLike;
+    graphId: string;
+    graphName: string;
+}
+export interface EntitySelectorProps {
+    graphsWithEntities: GraphWithEntities[];
+    currentEntity?: EntityLike | null;
+    currentGraphId?: string | null;
+    onEntityChange: (entity: EntityLike, graphId: string, graphName: string) => Promise<void>;
+    filter?: (entity: EntityLike, graphId: string) => boolean;
+    graphFilter?: (graph: GraphWithEntities) => boolean;
+    title?: string;
+    placeholder?: string;
+    emptyStateMessage?: string;
+    emptyStateAction?: {
+        label: string;
+        href: string;
+    };
+    groupByGraph?: boolean;
+    isLoading?: boolean;
+    isChanging?: boolean;
+    className?: string;
+    additionalActions?: Array<{
+        label: string;
+        href: string;
+        icon?: React.ComponentType<{
+            className?: string;
+        }>;
+    }>;
+}
+export declare function EntitySelectorCore({ graphsWithEntities, currentEntity, currentGraphId, onEntityChange, filter, graphFilter, title, placeholder, emptyStateMessage, emptyStateAction, groupByGraph, isLoading, isChanging, className, additionalActions, }: EntitySelectorProps): React.JSX.Element;

package/components/EntitySelectorCore.js

@@ -0,0 +1,67 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { HiOfficeBuilding } from 'react-icons/hi';
+import { EntitySelector, } from './EntitySelector';
+// Transform entity to entity
+function entityToEntity(entity, graphId, graphName) {
+    return {
+        id: `${graphId}-${entity.identifier}`,
+        name: entity.name,
+        subtitle: graphName,
+        icon: HiOfficeBuilding,
+        metadata: { entity, graphId, graphName },
+        entity,
+        graphId,
+        graphName,
+    };
+}
+export function EntitySelectorCore({ graphsWithEntities, currentEntity, currentGraphId, onEntityChange, filter, graphFilter, title = 'Entity', placeholder = 'Select Entity', emptyStateMessage = 'No entities available', emptyStateAction, groupByGraph = false, isLoading = false, isChanging = false, className = '', additionalActions = [], }) {
+    // Transform entities to entities
+    const entities = React.useMemo(() => {
+        const filteredGraphs = graphFilter
+            ? graphsWithEntities.filter(graphFilter)
+            : graphsWithEntities;
+        const allEntities = [];
+        for (const graph of filteredGraphs) {
+            const filteredEntities = filter
+                ? graph.entities.filter((entity) => filter(entity, graph.graphId))
+                : graph.entities;
+            for (const entity of filteredEntities) {
+                allEntities.push(entityToEntity(entity, graph.graphId, graph.graphName));
+            }
+        }
+        return allEntities;
+    }, [graphsWithEntities, filter, graphFilter]);
+    // Get current entity record
+    const currentEntityRecord = React.useMemo(() => {
+        if (!currentEntity || !currentGraphId)
+            return null;
+        return (entities.find((e) => e.entity.identifier === currentEntity.identifier &&
+            e.graphId === currentGraphId) || null);
+    }, [currentEntity, currentGraphId, entities]);
+    // Handle entity change
+    const handleEntityChange = React.useCallback(async (entity) => {
+        await onEntityChange(entity.entity, entity.graphId, entity.graphName);
+    }, [onEntityChange]);
+    // Group entities by graph if requested
+    const groupBy = React.useMemo(() => {
+        if (!groupByGraph)
+            return undefined;
+        return (entities) => {
+            const groups = new Map();
+            for (const entity of entities) {
+                if (!groups.has(entity.graphId)) {
+                    groups.set(entity.graphId, {
+                        id: entity.graphId,
+                        name: entity.graphName,
+                        entities: [],
+                    });
+                }
+                groups.get(entity.graphId).entities.push(entity);
+            }
+            return Array.from(groups.values());
+        };
+    }, [groupByGraph]);
+    return (_jsx(EntitySelector, { entities: entities, currentEntity: currentEntityRecord, onEntityChange: handleEntityChange, title: title, placeholder: placeholder, emptyStateMessage: emptyStateMessage, emptyStateAction: emptyStateAction, groupBy: groupBy, isLoading: isLoading, isChanging: isChanging, className: className, defaultIcon: HiOfficeBuilding, additionalActions: additionalActions }));
+}

package/components/GraphSelectorCore.d.ts

@@ -0,0 +1,21 @@
+import type { GraphInfo } from '@robosystems/client';
+import React from 'react';
+export interface GraphSelectorProps {
+    filter?: (graph: GraphInfo) => boolean;
+    title?: string;
+    placeholder?: string;
+    emptyStateMessage?: string;
+    emptyStateAction?: {
+        label: string;
+        href: string;
+    };
+    className?: string;
+    additionalActions?: Array<{
+        label: string;
+        href: string;
+        icon?: React.ComponentType<{
+            className?: string;
+        }>;
+    }>;
+}
+export declare function GraphSelectorCore({ filter, title, placeholder, emptyStateMessage, emptyStateAction, className, additionalActions, }: GraphSelectorProps): React.JSX.Element;

package/components/GraphSelectorCore.js

@@ -0,0 +1,39 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { HiDatabase } from 'react-icons/hi';
+import { useGraphContext } from '../contexts/graph-context';
+import { EntitySelector } from './EntitySelector';
+function graphToEntity(graph) {
+    return {
+        id: graph.graphId,
+        name: graph.graphName,
+        subtitle: graph.isRepository
+            ? `Shared Repository • ${graph.role}`
+            : graph.role,
+        icon: HiDatabase,
+        metadata: Object.assign(Object.assign({}, graph), { isRepository: graph.isRepository }),
+        graphInfo: graph,
+    };
+}
+export function GraphSelectorCore({ filter, title = 'Graph', placeholder = 'Select Graph', emptyStateMessage = 'No graphs available', emptyStateAction, className = '', additionalActions = [], }) {
+    const { state, setCurrentGraph } = useGraphContext();
+    // Transform graphs to entities
+    const entities = React.useMemo(() => {
+        const filteredGraphs = filter ? state.graphs.filter(filter) : state.graphs;
+        return filteredGraphs.map(graphToEntity);
+    }, [state.graphs, filter]);
+    // Get current entity
+    const currentEntity = React.useMemo(() => {
+        if (!state.currentGraphId)
+            return null;
+        const currentGraph = state.graphs.find((g) => g.graphId === state.currentGraphId);
+        return currentGraph ? graphToEntity(currentGraph) : null;
+    }, [state.currentGraphId, state.graphs]);
+    // Handle entity change
+    const handleEntityChange = React.useCallback(async (entity) => {
+        // Update graph context (handles backend update and persistence)
+        await setCurrentGraph(entity.id);
+    }, [setCurrentGraph]);
+    return (_jsx(EntitySelector, { entities: entities, currentEntity: currentEntity, onEntityChange: handleEntityChange, title: title, placeholder: placeholder, emptyStateMessage: emptyStateMessage, emptyStateAction: emptyStateAction, isLoading: state.isLoading, className: className, defaultIcon: HiDatabase, additionalActions: additionalActions }));
+}

package/components/PageLayout.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+interface PageLayoutProps {
+    children: ReactNode;
+    variant?: 'constrained' | 'full-width';
+    className?: string;
+}
+export declare function PageLayout({ children, variant, className, }: PageLayoutProps): import("react").JSX.Element;
+export {};

package/components/PageLayout.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { twMerge } from 'tailwind-merge';
+export function PageLayout({ children, variant = 'constrained', className, }) {
+    return (_jsx("div", { className: twMerge('space-y-6 p-6', variant === 'constrained' && 'mx-auto max-w-7xl', className), children: children }));
+}