@object-ui/app-shell 3.3.0 → 3.3.1

package/dist/chrome/OnboardingWalkthrough.js

@@ -0,0 +1,11 @@
+/**
+ * OnboardingWalkthrough
+ *
+ * Intentionally disabled. The first-time onboarding dialog has been
+ * suppressed per product decision. To re-enable, restore the full
+ * implementation from git history (see the commit that introduced this stub).
+ * @module
+ */
+export function OnboardingWalkthrough() {
+    return null;
+}

package/dist/chrome/ThemeProvider.d.ts

@@ -0,0 +1,13 @@
+type Theme = "dark" | "light" | "system";
+type ThemeProviderProps = {
+    children: React.ReactNode;
+    defaultTheme?: Theme;
+    storageKey?: string;
+};
+type ThemeProviderState = {
+    theme: Theme;
+    setTheme: (theme: Theme) => void;
+};
+export declare function ThemeProvider({ children, defaultTheme, storageKey, ...props }: ThemeProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare const useTheme: () => ThemeProviderState;
+export {};

package/dist/chrome/ThemeProvider.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useState } from "react";
+const initialState = {
+    theme: "system",
+    setTheme: () => null,
+};
+const ThemeProviderContext = createContext(initialState);
+export function ThemeProvider({ children, defaultTheme = "system", storageKey = "vite-ui-theme", ...props }) {
+    const [theme, setTheme] = useState(() => localStorage.getItem(storageKey) || defaultTheme);
+    useEffect(() => {
+        const root = window.document.documentElement;
+        root.classList.remove("light", "dark");
+        if (theme === "system") {
+            const systemTheme = window.matchMedia("(prefers-color-scheme: dark)")
+                .matches
+                ? "dark"
+                : "light";
+            root.classList.add(systemTheme);
+            return;
+        }
+        root.classList.add(theme);
+    }, [theme]);
+    const value = {
+        theme,
+        setTheme: (theme) => {
+            localStorage.setItem(storageKey, theme);
+            setTheme(theme);
+        },
+    };
+    return (_jsx(ThemeProviderContext.Provider, { ...props, value: value, children: children }));
+}
+export const useTheme = () => {
+    const context = useContext(ThemeProviderContext);
+    if (context === undefined)
+        throw new Error("useTheme must be used within a ThemeProvider");
+    return context;
+};

package/dist/chrome/index.d.ts

@@ -0,0 +1,8 @@
+export { CommandPalette } from './CommandPalette';
+export { KeyboardShortcutsDialog } from './KeyboardShortcutsDialog';
+export { OnboardingWalkthrough } from './OnboardingWalkthrough';
+export { ConditionalAuthWrapper } from './ConditionalAuthWrapper';
+export { ConsoleToaster } from './ConsoleToaster';
+export { ErrorBoundary } from './ErrorBoundary';
+export { LoadingScreen } from './LoadingScreen';
+export { ThemeProvider, useTheme } from './ThemeProvider';

package/dist/chrome/index.js

@@ -0,0 +1,8 @@
+export { CommandPalette } from './CommandPalette';
+export { KeyboardShortcutsDialog } from './KeyboardShortcutsDialog';
+export { OnboardingWalkthrough } from './OnboardingWalkthrough';
+export { ConditionalAuthWrapper } from './ConditionalAuthWrapper';
+export { ConsoleToaster } from './ConsoleToaster';
+export { ErrorBoundary } from './ErrorBoundary';
+export { LoadingScreen } from './LoadingScreen';
+export { ThemeProvider, useTheme } from './ThemeProvider';

package/dist/console/AppContent.d.ts

@@ -0,0 +1,26 @@
+/**
+ * AppContent — inner SPA rendered under /apps/:appName/*.
+ *
+ * Owns the per-app shell: ConsoleLayout, CommandPalette, KeyboardShortcutsDialog,
+ * route table for object/dashboard/report/page views, and the global ModalForm
+ * used by ObjectView edit actions. The outer routing skeleton (BrowserRouter,
+ * AuthGuard, AdapterProvider, MetadataProvider, theme/toaster, /home, /login,
+ * /organizations) is provided by `createConsole` from @object-ui/app-shell.
+ */
+import { type ReactNode } from 'react';
+interface AppContentProps {
+    /**
+     * Extra <Route> elements appended to the inner /apps/:appName/* router.
+     * Hosts can use this to mount console-specific routes (e.g. /system, legacy
+     * metadata editor) without forking AppContent.
+     */
+    extraRoutes?: ReactNode;
+    /**
+     * Extra <Route> elements rendered when there is no active app but the URL
+     * matches a special path (create-app, system). Mirrors `extraRoutes` for
+     * the no-app branch.
+     */
+    extraRoutesNoApp?: ReactNode;
+}
+export declare function AppContent({ extraRoutes, extraRoutesNoApp }?: AppContentProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/console/AppContent.js

@@ -0,0 +1,266 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * AppContent — inner SPA rendered under /apps/:appName/*.
+ *
+ * Owns the per-app shell: ConsoleLayout, CommandPalette, KeyboardShortcutsDialog,
+ * route table for object/dashboard/report/page views, and the global ModalForm
+ * used by ObjectView edit actions. The outer routing skeleton (BrowserRouter,
+ * AuthGuard, AdapterProvider, MetadataProvider, theme/toaster, /home, /login,
+ * /organizations) is provided by `createConsole` from @object-ui/app-shell.
+ */
+import { Routes, Route, Navigate, useNavigate, useLocation, useParams } from 'react-router-dom';
+import { useState, useEffect, useCallback, lazy, Suspense, useMemo } from 'react';
+import { ModalForm } from '@object-ui/plugin-form';
+import { Empty, EmptyTitle, EmptyDescription, Button } from '@object-ui/components';
+import { toast } from 'sonner';
+import { SchemaRendererProvider, useActionRunner, useGlobalUndo } from '@object-ui/react';
+import { useObjectTranslation, useObjectLabel } from '@object-ui/i18n';
+import { useAuth } from '@object-ui/auth';
+import { useMetadata } from '../providers/MetadataProvider';
+import { useAdapter } from '../providers/AdapterProvider';
+import { ExpressionProvider, evaluateVisibility } from '../providers/ExpressionProvider';
+import { useRecentItems } from '../hooks/useRecentItems';
+import { ExpressionEvaluator } from '@object-ui/core';
+// Components (eagerly loaded — always needed)
+import { ConsoleLayout } from '../layout/ConsoleLayout';
+import { CommandPalette } from '../chrome/CommandPalette';
+import { ErrorBoundary } from '../chrome/ErrorBoundary';
+import { LoadingScreen } from '../chrome/LoadingScreen';
+import { ObjectView } from '../views/ObjectView';
+import { KeyboardShortcutsDialog } from '../chrome/KeyboardShortcutsDialog';
+import { OnboardingWalkthrough } from '../chrome/OnboardingWalkthrough';
+import { NavigationSyncEffect } from '../hooks/useNavigationSync';
+// Route-based code splitting — lazy-load less-frequently-used routes
+const RecordDetailView = lazy(() => import('../views/RecordDetailView').then(m => ({ default: m.RecordDetailView })));
+const DashboardView = lazy(() => import('../views/DashboardView').then(m => ({ default: m.DashboardView })));
+const PageView = lazy(() => import('../views/PageView').then(m => ({ default: m.PageView })));
+const ReportView = lazy(() => import('../views/ReportView').then(m => ({ default: m.ReportView })));
+const SearchResultsPage = lazy(() => import('../views/SearchResultsPage').then(m => ({ default: m.SearchResultsPage })));
+// Designer pages — sourced from @object-ui/plugin-designer so third-party hosts
+// can opt out by not registering these routes.
+const CreateAppPage = lazy(() => import('@object-ui/plugin-designer').then(m => ({ default: m.CreateAppPage })));
+const EditAppPage = lazy(() => import('@object-ui/plugin-designer').then(m => ({ default: m.EditAppPage })));
+const PageDesignPage = lazy(() => import('@object-ui/plugin-designer').then(m => ({ default: m.PageDesignPage })));
+const DashboardDesignPage = lazy(() => import('@object-ui/plugin-designer').then(m => ({ default: m.DashboardDesignPage })));
+export function AppContent({ extraRoutes, extraRoutesNoApp } = {}) {
+    const [connectionState, setConnectionState] = useState('disconnected');
+    const { user } = useAuth();
+    const dataSource = useAdapter();
+    const navigate = useNavigate();
+    const location = useLocation();
+    const { appName } = useParams();
+    const { apps, objects: allObjects, loading: metadataLoading, ensureType } = useMetadata();
+    const { t } = useObjectTranslation();
+    const { objectLabel } = useObjectLabel();
+    // Preload the metadata buckets that the routes under /apps/:appName/* assume
+    // are fully loaded by render time (the lazy MetadataProvider only eagerly
+    // loads `app`).
+    const [scopeMetaReady, setScopeMetaReady] = useState(!ensureType);
+    useEffect(() => {
+        if (!ensureType) {
+            setScopeMetaReady(true);
+            return;
+        }
+        let cancelled = false;
+        Promise.all([
+            ensureType('object'),
+            ensureType('dashboard'),
+            ensureType('report'),
+            ensureType('page'),
+        ]).finally(() => {
+            if (!cancelled)
+                setScopeMetaReady(true);
+        });
+        return () => { cancelled = true; };
+    }, [ensureType]);
+    const activeApps = apps.filter((a) => a.active !== false);
+    const activeApp = apps.find((a) => a.name === appName) ||
+        activeApps.find((a) => a.isDefault === true) ||
+        activeApps[0];
+    const [isDialogOpen, setIsDialogOpen] = useState(false);
+    const [editingRecord, setEditingRecord] = useState(null);
+    const [refreshKey, setRefreshKey] = useState(0);
+    const { addRecentItem } = useRecentItems();
+    const { execute: executeAction, runner } = useActionRunner();
+    useGlobalUndo({
+        dataSource: dataSource ?? undefined,
+        onUndo: (op) => {
+            toast.info(`Undo: ${op.description}`, { duration: 4000 });
+            setRefreshKey(k => k + 1);
+        },
+        onRedo: (op) => {
+            toast.info(`Redo: ${op.description}`, { duration: 3000 });
+            setRefreshKey(k => k + 1);
+        },
+    });
+    useEffect(() => {
+        runner.registerHandler('crud_success', async (action) => {
+            setIsDialogOpen(false);
+            setRefreshKey(k => k + 1);
+            toast.success(action.params?.message ?? 'Record saved successfully');
+            return { success: true, reload: true };
+        });
+        runner.registerHandler('dialog_cancel', async () => {
+            setIsDialogOpen(false);
+            return { success: true };
+        });
+        // NOTE: `flow` actions are handled at the per-view ActionProvider level
+        // (RecordDetailView / ObjectView) so they share the same ActionRunner that
+        // <action:button> renderers consume via useAction(). Do NOT register a
+        // `flow` handler on this top-level useActionRunner — it lives on a
+        // different ActionRunner instance and would never be invoked from the
+        // record/list action buttons.
+    }, [runner]);
+    useEffect(() => {
+        if (!dataSource)
+            return;
+        const unsub = dataSource.onConnectionStateChange((event) => {
+            setConnectionState(event.state);
+            if (event.error)
+                console.error('[Console] Connection error:', event.error);
+        });
+        setConnectionState(dataSource.getConnectionState());
+        return unsub;
+    }, [dataSource]);
+    const cleanParts = location.pathname.split('/').filter(Boolean);
+    let objectNameFromPath = cleanParts[2];
+    if (objectNameFromPath === 'view' ||
+        objectNameFromPath === 'record' ||
+        objectNameFromPath === 'page' ||
+        objectNameFromPath === 'dashboard' ||
+        objectNameFromPath === 'design') {
+        objectNameFromPath = '';
+    }
+    const currentObjectDef = allObjects.find((o) => o.name === objectNameFromPath);
+    const handleCrudSuccess = useCallback(() => {
+        const label = currentObjectDef ? objectLabel(currentObjectDef) : t('common.record', { defaultValue: 'Record' });
+        executeAction({
+            type: 'crud_success',
+            params: {
+                message: editingRecord
+                    ? t('form.updateSuccess', { object: label, defaultValue: `${label} updated successfully` })
+                    : t('form.createSuccess', { object: label, defaultValue: `${label} created successfully` }),
+            },
+        });
+    }, [executeAction, editingRecord, currentObjectDef, objectLabel, t]);
+    const handleDialogCancel = useCallback(() => {
+        executeAction({ type: 'dialog_cancel' });
+    }, [executeAction]);
+    // Track recent items on route change.
+    useEffect(() => {
+        if (!activeApp)
+            return;
+        const parts = location.pathname.split('/').filter(Boolean);
+        let objName = parts[2];
+        if (objName === 'view' || objName === 'record' || objName === 'page' || objName === 'dashboard' || objName === 'design') {
+            objName = '';
+        }
+        const basePath = `/apps/${activeApp.name}`;
+        if (objName) {
+            const obj = allObjects.find((o) => o.name === objName);
+            if (obj) {
+                addRecentItem({
+                    id: `object:${obj.name}`,
+                    label: obj.label || obj.name,
+                    href: `${basePath}/${obj.name}`,
+                    type: 'object',
+                });
+            }
+        }
+        else if (parts[2] === 'dashboard' && parts[3]) {
+            addRecentItem({
+                id: `dashboard:${parts[3]}`,
+                label: parts[3].replace(/[-_]/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase()),
+                href: `${basePath}/dashboard/${parts[3]}`,
+                type: 'dashboard',
+            });
+        }
+        else if (parts[2] === 'report' && parts[3]) {
+            addRecentItem({
+                id: `report:${parts[3]}`,
+                label: parts[3].replace(/[-_]/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase()),
+                href: `${basePath}/report/${parts[3]}`,
+                type: 'report',
+            });
+        }
+    }, [location.pathname, addRecentItem]); // eslint-disable-line react-hooks/exhaustive-deps
+    const handleEdit = (record) => {
+        setEditingRecord(record);
+        setIsDialogOpen(true);
+    };
+    const handleAppChange = (newAppName) => {
+        navigate(`/apps/${newAppName}`);
+    };
+    const expressionEvaluator = useMemo(() => new ExpressionEvaluator({
+        user: user ? { name: user.name, email: user.email, role: user.role ?? 'user' } : {},
+        app: activeApp || {},
+        data: editingRecord || {},
+    }), [user, activeApp, editingRecord]);
+    if (!dataSource || metadataLoading || !scopeMetaReady)
+        return _jsx(LoadingScreen, {});
+    const isCreateAppRoute = location.pathname.endsWith('/create-app');
+    const isSystemRoute = location.pathname.includes('/system');
+    if (!activeApp && !isCreateAppRoute && !isSystemRoute)
+        return (_jsx("div", { className: "h-screen flex items-center justify-center", children: _jsxs(Empty, { children: [_jsx(EmptyTitle, { children: "No Apps Configured" }), _jsx(EmptyDescription, { children: "No applications have been registered. Create your first app or visit System Settings to configure your environment." }), _jsxs("div", { className: "mt-4 flex flex-col sm:flex-row items-center gap-3", children: [_jsx(Button, { onClick: () => navigate('/create-app'), "data-testid": "create-first-app-btn", children: "Create Your First App" }), _jsx(Button, { variant: "outline", onClick: () => navigate('/apps/setup'), "data-testid": "go-to-settings-btn", children: "System Settings" })] })] }) }));
+    if (!activeApp && (isCreateAppRoute || isSystemRoute)) {
+        return (_jsx(Suspense, { fallback: _jsx(LoadingScreen, {}), children: _jsxs(Routes, { children: [_jsx(Route, { path: "create-app", element: _jsx(CreateAppPage, {}) }), extraRoutesNoApp] }) }));
+    }
+    const expressionUser = user
+        ? { name: user.name, email: user.email, role: user.role ?? 'user' }
+        : { name: 'Anonymous', email: '', role: 'guest' };
+    return (_jsxs(ExpressionProvider, { user: expressionUser, app: activeApp, data: {}, children: [_jsx(NavigationSyncEffect, {}), _jsxs(ConsoleLayout, { activeAppName: activeApp.name, activeApp: activeApp, onAppChange: handleAppChange, objects: allObjects, connectionState: connectionState, children: [_jsx(CommandPalette, { apps: apps, activeApp: activeApp, objects: allObjects, onAppChange: handleAppChange }), _jsx(KeyboardShortcutsDialog, {}), _jsx(OnboardingWalkthrough, {}), _jsxs(SchemaRendererProvider, { dataSource: dataSource || {}, children: [_jsx(ErrorBoundary, { children: _jsx(Suspense, { fallback: _jsx(LoadingScreen, {}), children: _jsxs(Routes, { children: [_jsx(Route, { path: "/", element: _jsx(Navigate, { to: findFirstRoute(activeApp.navigation || []), replace: true }) }), _jsx(Route, { path: ":objectName", element: _jsx(ObjectView, { dataSource: dataSource, objects: allObjects, onEdit: handleEdit }) }), _jsx(Route, { path: ":objectName/view/:viewId", element: _jsx(ObjectView, { dataSource: dataSource, objects: allObjects, onEdit: handleEdit }) }), _jsx(Route, { path: ":objectName/record/:recordId", element: _jsx(RecordDetailView, { dataSource: dataSource, objects: allObjects, onEdit: handleEdit }, refreshKey) }), _jsx(Route, { path: "dashboard/:dashboardName", element: _jsx(DashboardView, { dataSource: dataSource }) }), _jsx(Route, { path: "report/:reportName", element: _jsx(ReportView, { dataSource: dataSource }) }), _jsx(Route, { path: "page/:pageName", element: _jsx(PageView, {}) }), _jsx(Route, { path: "design/page/:pageName", element: _jsx(PageDesignPage, {}) }), _jsx(Route, { path: "design/dashboard/:dashboardName", element: _jsx(DashboardDesignPage, {}) }), _jsx(Route, { path: "search", element: _jsx(SearchResultsPage, {}) }), _jsx(Route, { path: "create-app", element: _jsx(CreateAppPage, {}) }), _jsx(Route, { path: "edit-app/:editAppName", element: _jsx(EditAppPage, {}) }), extraRoutes] }) }) }), currentObjectDef && (_jsx(ModalForm, { schema: {
+                                    type: 'object-form',
+                                    formType: 'modal',
+                                    objectName: currentObjectDef.name,
+                                    mode: editingRecord ? 'edit' : 'create',
+                                    recordId: editingRecord?.id,
+                                    title: editingRecord
+                                        ? t('form.editTitle', { object: objectLabel(currentObjectDef) })
+                                        : t('form.createTitle', { object: objectLabel(currentObjectDef) }),
+                                    description: editingRecord
+                                        ? t('form.editDescription', { object: objectLabel(currentObjectDef) })
+                                        : t('form.createDescription', { object: objectLabel(currentObjectDef) }),
+                                    open: isDialogOpen,
+                                    onOpenChange: setIsDialogOpen,
+                                    layout: 'vertical',
+                                    fields: currentObjectDef.fields
+                                        ? (Array.isArray(currentObjectDef.fields)
+                                            ? currentObjectDef.fields
+                                                .filter((f) => {
+                                                if (typeof f === 'string')
+                                                    return true;
+                                                return evaluateVisibility(f.visible, expressionEvaluator);
+                                            })
+                                                .map((f) => typeof f === 'string' ? f : f.name)
+                                            : Object.entries(currentObjectDef.fields)
+                                                .filter(([_, f]) => evaluateVisibility(f.visible, expressionEvaluator))
+                                                .map(([key]) => key))
+                                        : [],
+                                    onSuccess: handleCrudSuccess,
+                                    onCancel: handleDialogCancel,
+                                    showSubmit: true,
+                                    showCancel: true,
+                                    submitText: t('form.saveRecord'),
+                                    cancelText: t('common.cancel'),
+                                }, dataSource: dataSource }, editingRecord?.id || 'new'))] })] })] }));
+}
+function findFirstRoute(items) {
+    if (!items || items.length === 0)
+        return '';
+    for (const item of items) {
+        if (item.type === 'object')
+            return item.viewName ? `${item.objectName}/view/${item.viewName}` : `${item.objectName}`;
+        if (item.type === 'page')
+            return item.pageName ? `page/${item.pageName}` : '';
+        if (item.type === 'dashboard')
+            return item.dashboardName ? `dashboard/${item.dashboardName}` : '';
+        if (item.type === 'url')
+            continue;
+        if (item.type === 'group' && item.children) {
+            const childRoute = findFirstRoute(item.children);
+            if (childRoute !== '')
+                return childRoute;
+        }
+    }
+    return '';
+}

package/dist/console/ConsoleShell.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Console building blocks — composable JSX elements that consumers assemble in
+ * their own App.tsx to build the console routing tree.
+ *
+ * Previously this module exported a `createConsole(config)` factory that hid the
+ * routing tree behind a config object. In practice every real project wants to
+ * edit the routes directly (add /billing, tweak AuthGuard behaviour, reorder
+ * providers), so we now export the pieces and let consumers write ~40 lines of
+ * JSX in App.tsx. See examples/console-starter/src/App.tsx for a minimal example,
+ * apps/console/src/App.tsx for one with custom system routes + CreateApp.
+ */
+import { type ReactNode } from 'react';
+export declare function LoadingFallback(): import("react/jsx-runtime").JSX.Element;
+/**
+ * ConsoleShell — top-level provider stack shared by every console route.
+ * Wraps children in ThemeProvider + NavigationProvider + FavoritesProvider +
+ * Suspense so lazy route components get a default loading fallback and
+ * dark/light/system theme switching works out of the box.
+ *
+ * Place this inside a <BrowserRouter> and around your <Routes>:
+ *
+ *   <BrowserRouter>
+ *     <ConsoleShell>
+ *       <Routes>...</Routes>
+ *     </ConsoleShell>
+ *   </BrowserRouter>
+ */
+export declare function ConsoleShell({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * ConnectedShell — mounts the data layer (AdapterProvider + MetadataProvider).
+ * Use this around any route element that needs metadata access, i.e. anything
+ * rendering objects / dashboards / pages.
+ */
+export declare function ConnectedShell({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * RequireOrganization — redirects to /organizations when the multi-tenant
+ * feature is enabled (user has orgs but no active one). Single-tenant
+ * deployments (empty organizations list) render through.
+ */
+export declare function RequireOrganization({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * AuthenticatedRoute — convenience wrapper composing AuthGuard + ConnectedShell
+ * (+ optional RequireOrganization). Covers the common case for protected
+ * routes. For bespoke needs, compose the primitives directly.
+ */
+export declare function AuthenticatedRoute({ children, requireOrganization, loginPath, }: {
+    children: ReactNode;
+    requireOrganization?: boolean;
+    loginPath?: string;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * RootRedirect — element for <Route path="/" />. Waits for metadata to load
+ * then sends the user to /home.
+ */
+export declare function RootRedirect(): import("react/jsx-runtime").JSX.Element;
+/**
+ * SystemRedirect — forwards legacy /system/* URLs to the canonical
+ * /apps/setup/* location so bookmarks keep working. Suffix is preserved.
+ */
+export declare function SystemRedirect(): import("react/jsx-runtime").JSX.Element;

package/dist/console/ConsoleShell.js

@@ -0,0 +1,97 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * Console building blocks — composable JSX elements that consumers assemble in
+ * their own App.tsx to build the console routing tree.
+ *
+ * Previously this module exported a `createConsole(config)` factory that hid the
+ * routing tree behind a config object. In practice every real project wants to
+ * edit the routes directly (add /billing, tweak AuthGuard behaviour, reorder
+ * providers), so we now export the pieces and let consumers write ~40 lines of
+ * JSX in App.tsx. See examples/console-starter/src/App.tsx for a minimal example,
+ * apps/console/src/App.tsx for one with custom system routes + CreateApp.
+ */
+import { Suspense } from 'react';
+import { Navigate, useLocation } from 'react-router-dom';
+import { AuthGuard, useAuth } from '@object-ui/auth';
+import { AdapterProvider, useAdapter } from '../providers/AdapterProvider';
+import { MetadataProvider, useMetadata } from '../providers/MetadataProvider';
+import { NavigationProvider } from '../context/NavigationContext';
+import { FavoritesProvider } from '../context/FavoritesProvider';
+import { ThemeProvider } from '../chrome/ThemeProvider';
+export function LoadingFallback() {
+    return (_jsx("div", { className: "h-screen flex items-center justify-center text-sm text-muted-foreground", children: "Loading\u2026" }));
+}
+/**
+ * ConsoleShell — top-level provider stack shared by every console route.
+ * Wraps children in ThemeProvider + NavigationProvider + FavoritesProvider +
+ * Suspense so lazy route components get a default loading fallback and
+ * dark/light/system theme switching works out of the box.
+ *
+ * Place this inside a <BrowserRouter> and around your <Routes>:
+ *
+ *   <BrowserRouter>
+ *     <ConsoleShell>
+ *       <Routes>...</Routes>
+ *     </ConsoleShell>
+ *   </BrowserRouter>
+ */
+export function ConsoleShell({ children }) {
+    return (_jsx(ThemeProvider, { defaultTheme: "system", storageKey: "object-ui-theme", children: _jsx(NavigationProvider, { children: _jsx(FavoritesProvider, { children: _jsx(Suspense, { fallback: _jsx(LoadingFallback, {}), children: children }) }) }) }));
+}
+/**
+ * ConnectedShell — mounts the data layer (AdapterProvider + MetadataProvider).
+ * Use this around any route element that needs metadata access, i.e. anything
+ * rendering objects / dashboards / pages.
+ */
+export function ConnectedShell({ children }) {
+    return (_jsx(AdapterProvider, { children: _jsx(ConnectedShellInner, { children: children }) }));
+}
+function ConnectedShellInner({ children }) {
+    const adapter = useAdapter();
+    if (!adapter)
+        return _jsx(LoadingFallback, {});
+    return _jsx(MetadataProvider, { adapter: adapter, children: children });
+}
+/**
+ * RequireOrganization — redirects to /organizations when the multi-tenant
+ * feature is enabled (user has orgs but no active one). Single-tenant
+ * deployments (empty organizations list) render through.
+ */
+export function RequireOrganization({ children }) {
+    const { activeOrganization, organizations, isOrganizationsLoading } = useAuth();
+    if (isOrganizationsLoading)
+        return _jsx(LoadingFallback, {});
+    const orgList = organizations ?? [];
+    const orgFeatureEnabled = orgList.length > 0 || !!activeOrganization;
+    if (orgFeatureEnabled && !activeOrganization)
+        return _jsx(Navigate, { to: "/organizations", replace: true });
+    return _jsx(_Fragment, { children: children });
+}
+/**
+ * AuthenticatedRoute — convenience wrapper composing AuthGuard + ConnectedShell
+ * (+ optional RequireOrganization). Covers the common case for protected
+ * routes. For bespoke needs, compose the primitives directly.
+ */
+export function AuthenticatedRoute({ children, requireOrganization = true, loginPath = '/login', }) {
+    return (_jsx(AuthGuard, { fallback: _jsx(Navigate, { to: loginPath }), loadingFallback: _jsx(LoadingFallback, {}), children: _jsx(ConnectedShell, { children: requireOrganization ? _jsx(RequireOrganization, { children: children }) : children }) }));
+}
+/**
+ * RootRedirect — element for <Route path="/" />. Waits for metadata to load
+ * then sends the user to /home.
+ */
+export function RootRedirect() {
+    const { loading } = useMetadata();
+    if (loading)
+        return _jsx(LoadingFallback, {});
+    return _jsx(Navigate, { to: "/home", replace: true });
+}
+/**
+ * SystemRedirect — forwards legacy /system/* URLs to the canonical
+ * /apps/setup/* location so bookmarks keep working. Suffix is preserved.
+ */
+export function SystemRedirect() {
+    const location = useLocation();
+    const suffix = location.pathname.replace(/^\/system/, '');
+    const target = suffix ? `/apps/setup/system${suffix}` : '/apps/setup';
+    return _jsx(Navigate, { to: `${target}${location.search}${location.hash}`, replace: true });
+}

package/dist/console/auth/AuthPageLayout.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared layout for authentication pages (login, register, forgot password).
+ * Provides a widescreen-optimized split-panel design with branding on the left
+ * and form content on the right, inspired by enterprise platforms like Airtable and Salesforce.
+ */
+import type React from 'react';
+export declare function AuthPageLayout({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/console/auth/AuthPageLayout.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function AuthPageLayout({ children }) {
+    return (_jsxs("div", { className: "flex min-h-screen", children: [_jsx("div", { className: "hidden lg:flex lg:w-1/2 items-center justify-center bg-primary p-12", children: _jsxs("div", { className: "max-w-md space-y-6 text-primary-foreground", children: [_jsxs("div", { className: "flex items-center gap-3", children: [_jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", className: "h-10 w-10", role: "img", "aria-label": "ObjectStack logo", children: [_jsx("title", { children: "ObjectStack" }), _jsx("path", { d: "M15 6v12a3 3 0 1 0 3-3H6a3 3 0 1 0 3 3V6a3 3 0 1 0-3 3h12a3 3 0 1 0-3-3" })] }), _jsx("span", { className: "text-2xl font-bold", children: "ObjectStack" })] }), _jsx("h2", { className: "text-3xl font-bold leading-tight", children: "Build powerful business applications, faster." }), _jsx("p", { className: "text-lg opacity-90", children: "The universal platform for enterprise data management, workflows, and analytics." })] }) }), _jsx("div", { className: "flex w-full lg:w-1/2 items-center justify-center bg-background px-6 py-12", children: children })] }));
+}

package/dist/console/auth/ForgotPasswordPage.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Forgot Password Page for ObjectStack Console
+ */
+export declare function ForgotPasswordPage(): import("react/jsx-runtime").JSX.Element;

package/dist/console/auth/ForgotPasswordPage.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Forgot Password Page for ObjectStack Console
+ */
+import { Link } from 'react-router-dom';
+import { ForgotPasswordForm } from '@object-ui/auth';
+import { useObjectTranslation } from '@object-ui/i18n';
+import { AuthPageLayout } from './AuthPageLayout';
+const RouterLink = ({ href, className, children }) => (_jsx(Link, { to: href, className: className, children: children }));
+export function ForgotPasswordPage() {
+    const { t } = useObjectTranslation();
+    return (_jsx(AuthPageLayout, { children: _jsx(ForgotPasswordForm, { loginUrl: "/login", title: t('auth.forgotPassword.title'), description: t('auth.forgotPassword.description'), linkComponent: RouterLink, labels: {
+                emailLabel: t('auth.forgotPassword.emailLabel'),
+                emailPlaceholder: t('auth.forgotPassword.emailPlaceholder'),
+                submitButton: t('auth.forgotPassword.submitButton'),
+                submittingButton: t('auth.forgotPassword.submittingButton'),
+                successTitle: t('auth.forgotPassword.successTitle'),
+                successDescription: t('auth.forgotPassword.successDescription'),
+                backToSignInText: t('auth.forgotPassword.backToSignInText'),
+                rememberPasswordText: t('auth.forgotPassword.rememberPasswordText'),
+                signInText: t('auth.forgotPassword.signInText'),
+            } }) }));
+}

package/dist/console/auth/LoginPage.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Login Page for ObjectStack Console
+ */
+export declare function LoginPage(): import("react/jsx-runtime").JSX.Element;

package/dist/console/auth/LoginPage.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Login Page for ObjectStack Console
+ */
+import { useNavigate, Link } from 'react-router-dom';
+import { LoginForm } from '@object-ui/auth';
+import { useObjectTranslation } from '@object-ui/i18n';
+import { AuthPageLayout } from './AuthPageLayout';
+const RouterLink = ({ href, className, children }) => (_jsx(Link, { to: href, className: className, children: children }));
+export function LoginPage() {
+    const navigate = useNavigate();
+    const { t } = useObjectTranslation();
+    return (_jsx(AuthPageLayout, { children: _jsx(LoginForm, { onSuccess: () => navigate('/'), registerUrl: "/register", forgotPasswordUrl: "/forgot-password", title: t('auth.login.title'), description: t('auth.login.description'), linkComponent: RouterLink, labels: {
+                emailLabel: t('auth.login.emailLabel'),
+                emailPlaceholder: t('auth.login.emailPlaceholder'),
+                passwordLabel: t('auth.login.passwordLabel'),
+                passwordPlaceholder: t('auth.login.passwordPlaceholder'),
+                forgotPasswordText: t('auth.login.forgotPasswordText'),
+                submitButton: t('auth.login.submitButton'),
+                submittingButton: t('auth.login.submittingButton'),
+                noAccountText: t('auth.login.noAccountText'),
+                signUpText: t('auth.login.signUpText'),
+            } }) }));
+}

package/dist/console/auth/RegisterPage.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Register Page for ObjectStack Console
+ */
+export declare function RegisterPage(): import("react/jsx-runtime").JSX.Element;