@object-ui/app-shell 11.3.0 → 11.5.0

package/dist/utils/recordFormNavigation.d.ts

@@ -115,6 +115,46 @@ export interface FormViewModalLayout {
  * out the form.
  */
 export declare function resolveFormViewLayout(objectDef: ObjectDefinitionForFormView | null | undefined): FormViewModalLayout;
+/**
+ * Result of the post-create-save navigation decision (#2604 save invariant:
+ * *create takes you to the record you made*). `kind: 'none'` means stay put
+ * (no usable record id came back from the save).
+ */
+export type PostCreateTarget = {
+    kind: 'none';
+} | {
+    kind: 'detail-page' | 'detail-drawer';
+    url: string;
+};
+/**
+ * Decide where a CREATE save lands (#2604): the new record's detail, on the
+ * record's own derived surface.
+ *
+ *   - `surface: 'page'` (field-heavy) → the detail ROUTE
+ *     `{baseUrl}/{objectName}/record/{id}` — deep-linkable, and the detail
+ *     page's own "← all records" affordance covers the way back.
+ *   - `surface: 'drawer'` (light) → the CURRENT list route with
+ *     `?recordId={id}` — the detail drawer opens OVER the still-intact list
+ *     (ObjectView treats that param as the drawer's source of truth), so the
+ *     list context is preserved for free.
+ *
+ * The `form` overlay param is stripped from the drawer URL so the create
+ * overlay does not reopen underneath the drawer. Pure and router-free: the
+ * caller derives `surface` (deriveRecordSurface) and performs the navigation
+ * (with `replace: true`, so Back skips the transient form state).
+ */
+export declare function resolvePostCreateTarget(opts: {
+    objectName: string;
+    baseUrl: string;
+    /** Current location pathname (the list route the create started from). */
+    pathname: string;
+    /** Current location search (query string, with or without leading `?`). */
+    search?: string;
+    /** The record's derived VIEW surface (`deriveRecordSurface(objectDef)`). */
+    surface: 'page' | 'drawer';
+    /** Saved record id (`result.id ?? result._id`). */
+    recordId: unknown;
+}): PostCreateTarget;
 /**
  * Action descriptor accepted by the navigate-create / navigate-edit
  * handlers. Loose-typed because the same shape is constructed dynamically

package/dist/utils/recordFormNavigation.js

@@ -76,6 +76,36 @@ export function resolveFormViewLayout(objectDef) {
     }
     return layout;
 }
+/**
+ * Decide where a CREATE save lands (#2604): the new record's detail, on the
+ * record's own derived surface.
+ *
+ *   - `surface: 'page'` (field-heavy) → the detail ROUTE
+ *     `{baseUrl}/{objectName}/record/{id}` — deep-linkable, and the detail
+ *     page's own "← all records" affordance covers the way back.
+ *   - `surface: 'drawer'` (light) → the CURRENT list route with
+ *     `?recordId={id}` — the detail drawer opens OVER the still-intact list
+ *     (ObjectView treats that param as the drawer's source of truth), so the
+ *     list context is preserved for free.
+ *
+ * The `form` overlay param is stripped from the drawer URL so the create
+ * overlay does not reopen underneath the drawer. Pure and router-free: the
+ * caller derives `surface` (deriveRecordSurface) and performs the navigation
+ * (with `replace: true`, so Back skips the transient form state).
+ */
+export function resolvePostCreateTarget(opts) {
+    const { objectName, baseUrl, pathname, search, surface, recordId } = opts;
+    if (recordId == null || recordId === '' || !objectName)
+        return { kind: 'none' };
+    const encoded = encodeURIComponent(String(recordId));
+    if (surface === 'page') {
+        return { kind: 'detail-page', url: `${baseUrl}/${objectName}/record/${encoded}` };
+    }
+    const sp = new URLSearchParams(search ?? '');
+    sp.delete('form');
+    sp.set('recordId', String(recordId));
+    return { kind: 'detail-drawer', url: `${pathname}?${sp.toString()}` };
+}
 /**
  * Resolve the URL for a `navigate_create` action.
  *

package/dist/utils/resolveViewId.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Resolve a URL-requested view name against the object's actual view ids.
+ *
+ * Canonical view ids are fully qualified (`<object>.<viewKind>`, see
+ * MetadataProvider), but nav items emit their `viewName` verbatim — usually
+ * the short form — and legacy embedded listViews carry bare keys (including
+ * the `'all'` fallback view). Accept both directions (#2217):
+ *
+ * 1. exact id match;
+ * 2. short name (no `.`) → retry as `<objectName>.<name>`;
+ * 3. qualified name → retry with the `<objectName>.` prefix stripped.
+ *
+ * Returns the matching view id, or `undefined` when nothing matches — the
+ * caller decides how to fall back (and should warn rather than swallow it).
+ */
+export declare function resolveViewId(requested: string | undefined | null, viewIds: readonly string[], objectName: string): string | undefined;

package/dist/utils/resolveViewId.js

@@ -0,0 +1,37 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Resolve a URL-requested view name against the object's actual view ids.
+ *
+ * Canonical view ids are fully qualified (`<object>.<viewKind>`, see
+ * MetadataProvider), but nav items emit their `viewName` verbatim — usually
+ * the short form — and legacy embedded listViews carry bare keys (including
+ * the `'all'` fallback view). Accept both directions (#2217):
+ *
+ * 1. exact id match;
+ * 2. short name (no `.`) → retry as `<objectName>.<name>`;
+ * 3. qualified name → retry with the `<objectName>.` prefix stripped.
+ *
+ * Returns the matching view id, or `undefined` when nothing matches — the
+ * caller decides how to fall back (and should warn rather than swallow it).
+ */
+export function resolveViewId(requested, viewIds, objectName) {
+    if (!requested)
+        return undefined;
+    const has = (id) => viewIds.includes(id);
+    if (has(requested))
+        return requested;
+    const prefix = `${objectName}.`;
+    if (!requested.includes('.') && has(prefix + requested)) {
+        return prefix + requested;
+    }
+    if (requested.startsWith(prefix) && has(requested.slice(prefix.length))) {
+        return requested.slice(prefix.length);
+    }
+    return undefined;
+}

package/dist/utils/warnSuppressedListNav.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export declare function warnSuppressedListNav(objectName: string, viewId: string, viewDef: Record<string, unknown> | null | undefined, listSchema: Record<string, unknown> | null | undefined): boolean;
+/** Test-only: clear the one-shot warning memory. */
+export declare function resetSuppressedListNavWarnings(): void;

package/dist/utils/warnSuppressedListNav.js

@@ -0,0 +1,40 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * ADR-0053: on an object's default list ("views" mode) the ViewTabBar is the
+ * only navigation control — `userFilters` / `quickFilters` belong to page
+ * lists (InterfaceListPage, "filters" mode) and are suppressed by
+ * `ObjectView.renderListView`.
+ *
+ * The suppression is correct, but until the phase-4 guardrail (zod `refine`
+ * + `check` rule) lands, an author who puts `userFilters` on an object list
+ * view gets a valid schema and a page that renders nothing where they expect
+ * filter controls — zero signal at any layer (#2219). Surface the drop with
+ * a one-shot console warning per object/view.
+ *
+ * Returns whether the view carried a suppressed field (mainly for tests).
+ */
+const warned = new Set();
+export function warnSuppressedListNav(objectName, viewId, viewDef, listSchema) {
+    const offending = ['userFilters', 'quickFilters'].filter((k) => (viewDef?.[k] ?? listSchema?.[k]) != null);
+    if (offending.length === 0)
+        return false;
+    const key = `${objectName}.${viewId}`;
+    if (!warned.has(key)) {
+        warned.add(key);
+        console.warn(`[ObjectView] View "${viewId}" on object "${objectName}" defines ` +
+            `${offending.join(' and ')}, which are ignored on an object list view ` +
+            `(ADR-0053 "views" mode — the view switcher is the only nav control here). ` +
+            `Move them to a page list (InterfaceListPage "filters" mode).`);
+    }
+    return true;
+}
+/** Test-only: clear the one-shot warning memory. */
+export function resetSuppressedListNavWarnings() {
+    warned.clear();
+}

package/dist/views/InterfaceListPage.d.ts

@@ -27,6 +27,7 @@ interface InterfaceListPageProps {
      * toolbar buttons don't sit under it. */
     reserveEditAffordance?: boolean;
 }
+export declare function defaultColumnsFromObject(objectDef: any): string[];
 export declare function defaultKanbanFromObject(objectDef: any): {
     groupField: string;
     groupByField: string;

package/dist/views/InterfaceListPage.js

@@ -53,17 +53,19 @@ function resolveSourceView(objectDef, sourceView) {
 /**
  * Default column set when the resolved view carries none — mirrors
  * ObjectView's data-mode fallback so an interface page never renders a
- * column-less grid. Priority: curated `compactLayout`, else the first
- * business fields (system/audit columns excluded).
+ * column-less grid. Priority: the `highlightFields` semantic role
+ * (ADR-0085), else the first business fields (system/audit columns
+ * excluded).
  */
 const SYSTEM_FIELDS = new Set([
     'id', 'created_at', 'createdAt', 'updated_at', 'updatedAt',
     'deleted_at', 'deletedAt', 'created_by', 'createdBy',
     'updated_by', 'updatedBy', '_version', '_rev',
 ]);
-function defaultColumnsFromObject(objectDef) {
-    if (Array.isArray(objectDef?.compactLayout) && objectDef.compactLayout.length > 0) {
-        return objectDef.compactLayout.filter((n) => objectDef.fields?.[n]);
+export function defaultColumnsFromObject(objectDef) {
+    const curated = objectDef?.highlightFields;
+    if (Array.isArray(curated) && curated.length > 0) {
+        return curated.filter((n) => objectDef.fields?.[n]);
     }
     const fields = objectDef?.fields;
     if (fields && typeof fields === 'object') {

package/dist/views/ObjectDataPage.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Object Data Page — the parameterized bare data surface (ADR-0055, #2251).
+ *
+ * Route: `/apps/:appName/:objectName/data` (± `filter[<field>]=<value>` and
+ * `uf_<field>` search params).
+ *
+ * Where ObjectView anchors to a saved list view (default or `/view/:viewId`),
+ * this surface is deliberately UNANCHORED — "the URL is the view":
+ *
+ *   • no saved-view filter is baked in: URL `filter[...]` conditions apply on
+ *     top of everything the user is allowed to see (row-level security is the
+ *     server-enforced baseline, never a view);
+ *   • URL conditions render as visible, removable chips (unlike Odoo's
+ *     invisible action domain);
+ *   • no saved-view tab bar — switching to a saved view is an explicit
+ *     navigation to `/view/:viewId` ("Save as view" is the exit);
+ *   • nothing here writes back to any saved view;
+ *   • the visualization switcher (grid/kanban/...) is ListView-internal, so
+ *     switching presentation never touches the URL — filter state survives;
+ *   • the common filter bar (ADR-0047 `userFilters` + `uf_*` persistence) is
+ *     auto-derived from the object's enum-ish fields, since there is no view
+ *     to author it on (ADR-0053 puts userFilters on views/pages).
+ *
+ * Field-level security: auto-derived columns, the filter bar, and URL filter
+ * predicates are all trimmed to readable fields client-side; the server is
+ * the enforcement point (it must drop predicates on unreadable fields).
+ */
+import * as React from 'react';
+export declare function ObjectDataPage({ dataSource, objects }: any): React.JSX.Element;

package/dist/views/ObjectDataPage.js

@@ -0,0 +1,227 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * Object Data Page — the parameterized bare data surface (ADR-0055, #2251).
+ *
+ * Route: `/apps/:appName/:objectName/data` (± `filter[<field>]=<value>` and
+ * `uf_<field>` search params).
+ *
+ * Where ObjectView anchors to a saved list view (default or `/view/:viewId`),
+ * this surface is deliberately UNANCHORED — "the URL is the view":
+ *
+ *   • no saved-view filter is baked in: URL `filter[...]` conditions apply on
+ *     top of everything the user is allowed to see (row-level security is the
+ *     server-enforced baseline, never a view);
+ *   • URL conditions render as visible, removable chips (unlike Odoo's
+ *     invisible action domain);
+ *   • no saved-view tab bar — switching to a saved view is an explicit
+ *     navigation to `/view/:viewId` ("Save as view" is the exit);
+ *   • nothing here writes back to any saved view;
+ *   • the visualization switcher (grid/kanban/...) is ListView-internal, so
+ *     switching presentation never touches the URL — filter state survives;
+ *   • the common filter bar (ADR-0047 `userFilters` + `uf_*` persistence) is
+ *     auto-derived from the object's enum-ish fields, since there is no view
+ *     to author it on (ADR-0053 puts userFilters on views/pages).
+ *
+ * Field-level security: auto-derived columns, the filter bar, and URL filter
+ * predicates are all trimmed to readable fields client-side; the server is
+ * the enforcement point (it must drop predicates on unreadable fields).
+ */
+import * as React from 'react';
+import { useParams, useNavigate, useSearchParams } from 'react-router-dom';
+import { ListView } from '@object-ui/plugin-list';
+import { useNavigationOverlay } from '@object-ui/react';
+import { Button, Empty, EmptyTitle, EmptyDescription, NavigationOverlay, } from '@object-ui/components';
+import { Database, Lock, Plus, Save, X } from 'lucide-react';
+import { useObjectTranslation, useObjectLabel } from '@object-ui/i18n';
+import { usePermissions, useFieldPermissions } from '@object-ui/permissions';
+import { useAuth, useIsWorkspaceAdmin } from '@object-ui/auth';
+import { parseUserFilterParams, applyUserFilterParams } from './userFilterUrlState';
+import { defaultColumnsFromObject, defaultKanbanFromObject, defaultCalendarFromObject, defaultGalleryFromObject, } from './InterfaceListPage';
+import { RecordDetailView } from './RecordDetailView';
+import { PageHeader } from '../layout/PageHeader';
+import { getIcon } from '../utils/getIcon';
+import { useMetadataClient } from './metadata-admin/useMetadata';
+import { createRuntimeMetadata } from './runtime-metadata-persistence';
+import { CreateViewDialog } from './CreateViewDialog';
+/** Parse `filter[<field>]=<value>` search params into equality triples. */
+function parseUrlFilterTriples(searchParams) {
+    const out = [];
+    searchParams.forEach((value, key) => {
+        const m = /^filter\[(.+)\]$/.exec(key);
+        if (m && m[1] && value !== '')
+            out.push([m[1], '=', value]);
+    });
+    return out;
+}
+/** Field types the auto-derived user-filter bar offers as dropdowns. */
+const USER_FILTER_TYPES = new Set(['select', 'multiselect', 'radio', 'enum', 'boolean']);
+const MAX_USER_FILTERS = 4;
+export function ObjectDataPage({ dataSource, objects }) {
+    const { appName, objectName } = useParams();
+    const { t } = useObjectTranslation();
+    const { objectLabel, fieldLabel } = useObjectLabel();
+    const navigate = useNavigate();
+    const [searchParams, setSearchParams] = useSearchParams();
+    const { can } = usePermissions();
+    const { canRead } = useFieldPermissions(objectName ?? '');
+    const { user } = useAuth();
+    const isAdmin = useIsWorkspaceAdmin();
+    const metadataClient = useMetadataClient();
+    const [showCreateViewDialog, setShowCreateViewDialog] = React.useState(false);
+    const objectDef = React.useMemo(() => (objects || []).find((o) => o.name === objectName), [objects, objectName]);
+    // ADR-0047 filter persistence — same wiring as InterfaceListPage: restore
+    // `uf_*` once at mount, mirror selection changes back (replace, no history
+    // spam).
+    const [initialUfSelections] = React.useState(() => parseUserFilterParams(new URLSearchParams(window.location.search)));
+    const handleUserFilterSelectionsChange = React.useCallback((selections) => {
+        setSearchParams((prev) => applyUserFilterParams(prev, selections), { replace: true });
+    }, [setSearchParams]);
+    // URL filter triples, trimmed to readable fields. Predicates on unreadable
+    // fields are dropped here for UX honesty; the SERVER is the actual
+    // enforcement point against filter-oracle probing.
+    const filterParamsKey = Array.from(searchParams.entries())
+        .filter(([k]) => k.startsWith('filter['))
+        .map(([k, v]) => `${k}=${v}`)
+        .join('&');
+    const urlFilters = React.useMemo(() => {
+        const all = parseUrlFilterTriples(new URLSearchParams(filterParamsKey));
+        const readable = all.filter(([field]) => canRead(field));
+        if (readable.length < all.length) {
+            const dropped = all.filter(([field]) => !canRead(field)).map(([field]) => field);
+            console.warn(`[ObjectDataPage] Dropped URL filter(s) on unreadable field(s): ${dropped.join(', ')}`);
+        }
+        // Template variables mirror nav `recordId` substitution so shared links
+        // can carry `{current_user_id}`.
+        return readable.map(([field, op, value]) => value === '{current_user_id}' ? [field, op, user?.id ?? value] : [field, op, value]);
+    }, [filterParamsKey, canRead, user?.id]);
+    const removeUrlFilter = React.useCallback((field) => {
+        setSearchParams((prev) => {
+            const next = new URLSearchParams(prev);
+            next.delete(`filter[${field}]`);
+            return next;
+        });
+    }, [setSearchParams]);
+    // Auto-derived columns + filter bar, both trimmed by field-level security.
+    const columns = React.useMemo(() => defaultColumnsFromObject(objectDef).filter((f) => canRead(f)), [objectDef, canRead]);
+    const userFilters = React.useMemo(() => {
+        const fields = objectDef?.fields;
+        if (!fields || typeof fields !== 'object')
+            return undefined;
+        const picks = Object.entries(fields)
+            .filter(([name, f]) => f && !f.hidden && USER_FILTER_TYPES.has(f.type) && canRead(name))
+            .slice(0, MAX_USER_FILTERS)
+            .map(([name]) => ({ field: name }));
+        return picks.length > 0 ? { element: 'dropdown', fields: picks } : undefined;
+    }, [objectDef, canRead]);
+    // Record open behavior — URL-driven drawer, same convention as ObjectView
+    // and InterfaceListPage (`?recordId=…` is shareable and refresh-safe).
+    const recordUrl = React.useCallback((id) => `/apps/${appName}/${objectName}/record/${encodeURIComponent(String(id))}`, [appName, objectName]);
+    const navOverlay = useNavigationOverlay({
+        navigation: { mode: 'drawer' },
+        objectName: objectName ?? '',
+        onNavigate: (id) => navigate(recordUrl(id)),
+    });
+    const drawerRecordId = searchParams.get('recordId');
+    const handleRecordClick = React.useCallback((record, event) => {
+        const id = record?.id ?? record?._id;
+        const isMod = !!(event && (event.metaKey || event.ctrlKey || event.button === 1));
+        if (isMod && id != null) {
+            window.open(recordUrl(id), '_blank');
+            return;
+        }
+        if (id != null) {
+            setSearchParams((prev) => { const n = new URLSearchParams(prev); n.set('recordId', String(id)); return n; });
+        }
+    }, [recordUrl, setSearchParams]);
+    const closeRecordDrawer = React.useCallback(() => {
+        setSearchParams((prev) => { const n = new URLSearchParams(prev); n.delete('recordId'); return n; });
+    }, [setSearchParams]);
+    React.useEffect(() => {
+        if (drawerRecordId && !navOverlay.isOpen)
+            navOverlay.open({ id: drawerRecordId });
+        else if (!drawerRecordId && navOverlay.isOpen)
+            navOverlay.close();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [drawerRecordId]);
+    // Visualization whitelist: grid always; others only when a field binding
+    // resolves from the object. The switcher is ListView-internal, so switching
+    // presentation never rewrites the URL — filter params survive by
+    // construction (#2251 acceptance).
+    const kanban = React.useMemo(() => defaultKanbanFromObject(objectDef), [objectDef]);
+    const calendar = React.useMemo(() => defaultCalendarFromObject(objectDef), [objectDef]);
+    const gallery = React.useMemo(() => defaultGalleryFromObject(objectDef), [objectDef]);
+    const allowedVisualizations = React.useMemo(() => {
+        const allowed = ['grid'];
+        if (kanban)
+            allowed.push('kanban');
+        if (calendar)
+            allowed.push('calendar');
+        if (gallery)
+            allowed.push('gallery');
+        return allowed;
+    }, [kanban, calendar, gallery]);
+    const schema = React.useMemo(() => {
+        if (!objectDef)
+            return undefined;
+        return {
+            type: 'list-view',
+            objectName: objectDef.name,
+            viewType: 'grid',
+            fields: columns,
+            ...(urlFilters.length ? { filters: urlFilters } : {}),
+            kanban,
+            calendar,
+            gallery,
+            userFilters,
+            appearance: { allowedVisualizations },
+            showViewSwitcher: allowedVisualizations.length > 1,
+            // Full list capability — this surface trades the saved-view anchor for
+            // the complete toolbar, NOT for a reduced one.
+            showSearch: true,
+            showSort: true,
+            showFilters: true,
+            showGroup: true,
+            showHideFields: true,
+            showDensity: true,
+            showRecordCount: true,
+            // Deliberately NO onSortChange/onFilterChange persistence hooks: this
+            // surface never writes back to any saved view (#2251).
+        };
+    }, [objectDef, columns, urlFilters, kanban, calendar, gallery, userFilters, allowedVisualizations]);
+    // "Save as view" — the one exit into the workspace: materialize the current
+    // URL conditions as a new saved view, then navigate to it.
+    const handleSaveAsView = React.useCallback(async (config) => {
+        try {
+            const spec = {
+                ...config,
+                columns: Array.isArray(config.columns) && config.columns.length > 0 ? config.columns : columns,
+                ...(urlFilters.length ? { filter: urlFilters } : {}),
+            };
+            const draftName = String(config?.name ?? config?.id ?? '');
+            const createdId = await createRuntimeMetadata('view', draftName, spec, { metadataClient });
+            if (createdId)
+                navigate(`../view/${createdId}`, { relative: 'path' });
+        }
+        catch (err) {
+            console.error('[ObjectDataPage] Failed to save view:', err);
+        }
+    }, [columns, urlFilters, metadataClient, navigate]);
+    if (!objectDef) {
+        return (_jsx("div", { className: "h-full flex items-center justify-center p-8", children: _jsxs(Empty, { children: [_jsx("div", { className: "mx-auto mb-4 flex h-12 w-12 items-center justify-center rounded-full bg-muted", children: _jsx(Database, { className: "h-6 w-6 text-muted-foreground" }) }), _jsx(EmptyTitle, { children: t('console.objectView.objectNotFound') }), _jsx(EmptyDescription, { children: t('console.objectView.objectNotFoundDescription', { objectName }) })] }) }));
+    }
+    // Route gate — no read permission renders an explicit denial, never an
+    // empty list (#2251 security model). The server-enforced row filter is the
+    // real boundary; this is the honest UI for "you can't be here".
+    if (!can(objectDef.name, 'read')) {
+        return (_jsx("div", { className: "h-full flex items-center justify-center p-8", "data-testid": "object-data-403", children: _jsxs(Empty, { children: [_jsx("div", { className: "mx-auto mb-4 flex h-12 w-12 items-center justify-center rounded-full bg-muted", children: _jsx(Lock, { className: "h-6 w-6 text-muted-foreground" }) }), _jsx(EmptyTitle, { children: t('console.objectData.noAccessTitle', { defaultValue: 'Access denied' }) }), _jsx(EmptyDescription, { children: t('console.objectData.noAccess', {
+                            defaultValue: 'You do not have permission to view this data.',
+                        }) })] }) }));
+    }
+    return (_jsxs("div", { className: "h-full flex flex-col bg-background min-w-0 overflow-hidden", "data-testid": "object-data-page", children: [_jsx("div", { className: "hidden sm:block", children: _jsx(PageHeader, { title: _jsxs("span", { className: "inline-flex items-center gap-2", children: [_jsx("span", { className: "truncate", children: objectLabel(objectDef) }), _jsx("span", { className: "rounded border px-1.5 py-0.5 text-[10px] font-medium uppercase tracking-wide text-muted-foreground", children: t('console.objectData.badge', { defaultValue: 'Data' }) })] }), description: t('console.objectData.description', {
+                        defaultValue: 'URL-defined data slice — not bound to any saved view.',
+                    }), icon: React.createElement(getIcon(objectDef?.icon), { className: 'h-4 w-4' }), actions: _jsxs(_Fragment, { children: [can(objectDef.name, 'create') && (_jsxs(Button, { size: "sm", onClick: () => navigate('../new', { relative: 'path' }), className: "shadow-none gap-1.5 h-8 sm:h-9", "data-testid": "object-data-new-button", children: [_jsx(Plus, { className: "h-4 w-4" }), _jsx("span", { className: "hidden sm:inline", children: t('console.objectView.new') })] })), isAdmin && (_jsxs(Button, { size: "sm", variant: "outline", onClick: () => setShowCreateViewDialog(true), className: "shadow-none gap-1.5 h-8 sm:h-9", "data-testid": "object-data-save-as-view", children: [_jsx(Save, { className: "h-4 w-4" }), _jsx("span", { className: "hidden sm:inline", children: t('console.objectData.saveAsView', { defaultValue: 'Save as view' }) })] }))] }) }) }), urlFilters.length > 0 && (_jsxs("div", { className: "flex flex-wrap items-center gap-1.5 border-b px-3 sm:px-4 py-2 shrink-0", "data-testid": "object-data-filter-chips", children: [_jsx("span", { className: "text-xs text-muted-foreground", children: t('console.objectData.filteredBy', { defaultValue: 'Filtered by' }) }), urlFilters.map(([field, , value]) => (_jsxs("span", { className: "inline-flex items-center gap-1 rounded-full border bg-muted/40 px-2 py-0.5 text-xs", children: [_jsx("span", { className: "font-medium", children: fieldLabel(objectDef.name, field, field) }), _jsxs("span", { className: "text-muted-foreground", children: ["= ", String(value)] }), _jsx("button", { type: "button", onClick: () => removeUrlFilter(field), className: "ml-0.5 rounded-full hover:bg-muted p-0.5", "aria-label": t('console.objectData.removeFilter', {
+                                    defaultValue: 'Remove filter {{field}}',
+                                    field,
+                                }), "data-testid": `object-data-remove-filter-${field}`, children: _jsx(X, { className: "h-3 w-3" }) })] }, field)))] })), _jsx("div", { className: "flex-1 min-h-0 overflow-auto", children: schema && (_jsx(ListView, { schema: schema, dataSource: dataSource, userFilterSelections: initialUfSelections, onUserFilterSelectionsChange: handleUserFilterSelectionsChange, onRowClick: handleRecordClick })) }), navOverlay.isOverlay && (_jsx(NavigationOverlay, { ...navOverlay, setIsOpen: (open) => { if (!open)
+                    closeRecordDrawer(); }, title: objectLabel(objectDef), children: (record) => (_jsx(RecordDetailView, { objectNameOverride: objectDef.name, recordIdOverride: String(record?.id ?? record?._id ?? drawerRecordId ?? ''), embedded: true, dataSource: dataSource, objects: objects, onEdit: () => { } })) })), isAdmin && (_jsx(CreateViewDialog, { open: showCreateViewDialog, onOpenChange: setShowCreateViewDialog, onCreate: handleSaveAsView, objectDef: objectDef }))] }));
+}