@object-ui/app-shell 6.2.3 → 7.1.0

package/dist/context/RecentItemsProvider.d.ts

@@ -22,7 +22,7 @@ export interface RecentItem {
     id: string;
     label: string;
     href: string;
-    type: 'object' | 'dashboard' | 'page' | 'report' | 'record';
+    type: 'object' | 'dashboard' | 'page' | 'report' | 'record' | 'metadata';
     /** ISO timestamp of last visit */
     visitedAt: string;
 }
@@ -33,7 +33,7 @@ interface RecentItemsContextValue {
 }
 export declare function RecentItemsProvider({ children }: {
     children: ReactNode;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;
 /**
  * Access shared "recently-accessed" state.
  *

package/dist/context/UserStateAdapters.d.ts

@@ -30,7 +30,7 @@ export interface UserDataAdapter<T> {
 export type UserStateKind = 'favorites' | 'recent';
 export declare function UserStateAdaptersProvider({ children }: {
     children: ReactNode;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;
 /** Read the currently-attached adapter for a given kind. */
 export declare function useUserStateAdapter<T>(kind: UserStateKind): UserDataAdapter<T> | null;
 /**

package/dist/context/index.d.ts

@@ -3,5 +3,7 @@ export { FavoritesProvider, useFavorites } from './FavoritesProvider';
 export type { FavoriteItem } from './FavoritesProvider';
 export { RecentItemsProvider, useRecentItems } from './RecentItemsProvider';
 export type { RecentItem } from './RecentItemsProvider';
+export { CommandPaletteProvider, useCommandPalette, } from './CommandPaletteProvider';
+export type { CommandPaletteContextValue } from './CommandPaletteProvider';
 export { UserStateAdaptersProvider, useUserStateAdapter, useAttachUserStateAdapters, } from './UserStateAdapters';
 export type { UserDataAdapter, UserStateKind } from './UserStateAdapters';

package/dist/context/index.js

@@ -1,4 +1,5 @@
 export { NavigationProvider, useNavigationContext } from './NavigationContext';
 export { FavoritesProvider, useFavorites } from './FavoritesProvider';
 export { RecentItemsProvider, useRecentItems } from './RecentItemsProvider';
+export { CommandPaletteProvider, useCommandPalette, } from './CommandPaletteProvider';
 export { UserStateAdaptersProvider, useUserStateAdapter, useAttachUserStateAdapters, } from './UserStateAdapters';

package/dist/hooks/index.d.ts

@@ -1,11 +1,14 @@
 export { useFavorites, type FavoriteItem } from './useFavorites';
+export { useActionModal, type ModalDescriptor } from './useActionModal';
 export { useMetadataService } from './useMetadataService';
 export { useNavPins } from './useNavPins';
 export { useNavigationSync, NavigationSyncEffect, generateNavId, addNavigationItem, removeNavigationItems, renameNavigationItems, navigationEqual, type UseNavigationSyncReturn, } from './useNavigationSync';
 export { useObjectActions } from './useObjectActions';
 export { useRecentItems, type RecentItem } from './useRecentItems';
-export { useRecordApprovals, type ApprovalProcessLite, type ApprovalRequestLite } from './useRecordApprovals';
+export { useRecordApprovals, type ApprovalRequestLite } from './useRecordApprovals';
 export { useResponsiveSidebar } from './useResponsiveSidebar';
+export { useSettleSignal, type SettleSignalState } from './useSettleSignal';
+export { useUrlOverlay, type UseUrlOverlayOptions, type UrlOverlayControls, } from './useUrlOverlay';
 export { useTrackRouteAsRecent, type UseTrackRouteAsRecentOptions } from './useTrackRouteAsRecent';
-export { useChatConversation, type HydratedUIMessage, type UseChatConversationOptions, type UseChatConversationReturn, } from './useChatConversation';
+export { sanitizeChatMessagesForCache, useChatConversation, writeConversationMessagesCache, type HydratedUIMessage, type UseChatConversationOptions, type UseChatConversationReturn, } from './useChatConversation';
 export { useConversationList, type ConversationSummary, type UseConversationListOptions, type UseConversationListReturn, } from './useConversationList';

package/dist/hooks/index.js

@@ -1,4 +1,5 @@
 export { useFavorites } from './useFavorites';
+export { useActionModal } from './useActionModal';
 export { useMetadataService } from './useMetadataService';
 export { useNavPins } from './useNavPins';
 export { useNavigationSync, NavigationSyncEffect, generateNavId, addNavigationItem, removeNavigationItems, renameNavigationItems, navigationEqual, } from './useNavigationSync';
@@ -6,6 +7,8 @@ export { useObjectActions } from './useObjectActions';
 export { useRecentItems } from './useRecentItems';
 export { useRecordApprovals } from './useRecordApprovals';
 export { useResponsiveSidebar } from './useResponsiveSidebar';
+export { useSettleSignal } from './useSettleSignal';
+export { useUrlOverlay, } from './useUrlOverlay';
 export { useTrackRouteAsRecent } from './useTrackRouteAsRecent';
-export { useChatConversation, } from './useChatConversation';
+export { sanitizeChatMessagesForCache, useChatConversation, writeConversationMessagesCache, } from './useChatConversation';
 export { useConversationList, } from './useConversationList';

package/dist/hooks/useActionModal.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 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.
+ *
+ * useActionModal — a reusable `onModal` handler for the ActionProvider that
+ * renders an action's modal envelope in the right container by `placement`:
+ *
+ *   placement: 'center'      → Dialog (sized sm|default|lg|xl)
+ *   placement: 'fullscreen'  → Dialog, near-viewport
+ *   placement: 'side'        → Sheet (right|left)
+ *   placement: 'bottom'      → Drawer (bottom sheet)
+ *
+ * `content` is an arbitrary SchemaNode rendered via <SchemaRenderer>, so a
+ * modal action can open any page/form/list. Back-compat: a string target
+ * (e.g. "create_opportunity") or `{ objectName, mode }` opens a <ModalForm>.
+ *
+ * Returns `{ modalHandler, modalElement }`: pass `modalHandler` as the
+ * ActionProvider `onModal`, and render `modalElement` once in the subtree.
+ */
+import React from 'react';
+type Placement = 'center' | 'side' | 'bottom' | 'fullscreen';
+type ModalSize = 'sm' | 'default' | 'lg' | 'xl' | 'full';
+export interface ModalDescriptor {
+    placement?: Placement;
+    side?: 'left' | 'right';
+    size?: ModalSize;
+    title?: string;
+    description?: string;
+    /** Arbitrary SchemaNode rendered inside the chosen container. */
+    content?: any;
+    /** Back-compat: open an object form. */
+    objectName?: string;
+    mode?: string;
+    recordId?: string;
+    fields?: any;
+}
+type ActionResult = {
+    success: boolean;
+    reload?: boolean;
+    data?: any;
+    [k: string]: any;
+};
+/** Normalize the opaque `schema` arg the ActionRunner passes into a descriptor. */
+export declare function normalizeModalSchema(schema: any): ModalDescriptor;
+export declare function useActionModal(dataSource?: any): {
+    modalHandler: (schema: any) => Promise<ActionResult>;
+    modalElement: React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+    closeModal: (r: ActionResult) => void;
+};
+export {};

package/dist/hooks/useActionModal.js

@@ -0,0 +1,111 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * 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.
+ *
+ * useActionModal — a reusable `onModal` handler for the ActionProvider that
+ * renders an action's modal envelope in the right container by `placement`:
+ *
+ *   placement: 'center'      → Dialog (sized sm|default|lg|xl)
+ *   placement: 'fullscreen'  → Dialog, near-viewport
+ *   placement: 'side'        → Sheet (right|left)
+ *   placement: 'bottom'      → Drawer (bottom sheet)
+ *
+ * `content` is an arbitrary SchemaNode rendered via <SchemaRenderer>, so a
+ * modal action can open any page/form/list. Back-compat: a string target
+ * (e.g. "create_opportunity") or `{ objectName, mode }` opens a <ModalForm>.
+ *
+ * Returns `{ modalHandler, modalElement }`: pass `modalHandler` as the
+ * ActionProvider `onModal`, and render `modalElement` once in the subtree.
+ */
+import { useCallback, useState } from 'react';
+import { Button, Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle, Drawer, DrawerContent, DrawerDescription, DrawerHeader, DrawerTitle, Sheet, SheetContent, SheetDescription, SheetHeader, SheetTitle, cn, } from '@object-ui/components';
+import { SchemaRenderer } from '@object-ui/react';
+import { ModalForm } from '@object-ui/plugin-form';
+const SIZE_CLASS = {
+    sm: 'sm:max-w-sm',
+    default: 'sm:max-w-lg',
+    lg: 'sm:max-w-2xl',
+    xl: 'sm:max-w-5xl',
+    full: 'sm:max-w-[95vw] sm:w-full',
+};
+const SIDE_SIZE_CLASS = {
+    lg: 'sm:max-w-2xl',
+    xl: 'sm:max-w-3xl',
+    full: 'sm:max-w-[95vw]',
+};
+/** Normalize the opaque `schema` arg the ActionRunner passes into a descriptor. */
+export function normalizeModalSchema(schema) {
+    if (typeof schema === 'string') {
+        const m = schema.match(/^(create|new|add|edit|update)_(.+)$/);
+        if (m)
+            return { objectName: m[2], mode: m[1] === 'edit' || m[1] === 'update' ? 'edit' : 'create' };
+        return { objectName: schema, mode: 'create' };
+    }
+    if (schema && typeof schema === 'object') {
+        // A bare SchemaNode (has `type` but isn't a modal descriptor) → render as content.
+        if (schema.type && !schema.content && !schema.objectName && !schema.placement) {
+            return { content: schema };
+        }
+        return schema;
+    }
+    return {};
+}
+export function useActionModal(dataSource) {
+    const [state, setState] = useState(null);
+    const close = useCallback((r) => {
+        setState((s) => {
+            s?.resolve(r);
+            return null;
+        });
+    }, []);
+    const modalHandler = useCallback((schema) => new Promise((resolve) => {
+        setState({ d: normalizeModalSchema(schema), resolve });
+    }), []);
+    let modalElement = null;
+    if (state) {
+        const d = state.d;
+        const onOpenChange = (open) => {
+            if (!open)
+                close({ success: false });
+        };
+        if (d.objectName && !d.content) {
+            modalElement = (_jsx(ModalForm, { schema: {
+                    type: 'object-form',
+                    formType: 'modal',
+                    objectName: d.objectName,
+                    mode: d.mode || 'create',
+                    recordId: d.recordId,
+                    title: d.title,
+                    description: d.description,
+                    fields: d.fields,
+                    modalSize: d.size,
+                    open: true,
+                    onOpenChange,
+                    onSuccess: (data) => close({ success: true, reload: true, data }),
+                    onCancel: () => close({ success: false }),
+                    showSubmit: true,
+                    showCancel: true,
+                }, dataSource: dataSource }));
+        }
+        else {
+            const placement = d.placement || 'center';
+            const body = d.content ? (_jsx(SchemaRenderer, { schema: d.content })) : d.description ? (_jsx("p", { className: "text-sm text-muted-foreground", children: d.description })) : null;
+            if (placement === 'side') {
+                modalElement = (_jsx(Sheet, { open: true, onOpenChange: onOpenChange, children: _jsxs(SheetContent, { side: d.side || 'right', className: cn('w-full overflow-y-auto', SIDE_SIZE_CLASS[d.size || 'default']), children: [d.title && (_jsxs(SheetHeader, { children: [_jsx(SheetTitle, { children: d.title }), d.description && _jsx(SheetDescription, { children: d.description })] })), _jsx("div", { className: "py-3", children: body })] }) }));
+            }
+            else if (placement === 'bottom') {
+                modalElement = (_jsx(Drawer, { open: true, onOpenChange: onOpenChange, children: _jsxs(DrawerContent, { children: [d.title && (_jsxs(DrawerHeader, { children: [_jsx(DrawerTitle, { children: d.title }), d.description && _jsx(DrawerDescription, { children: d.description })] })), _jsx("div", { className: "max-h-[75vh] overflow-y-auto px-4 pb-6", children: body })] }) }));
+            }
+            else {
+                modalElement = (_jsx(Dialog, { open: true, onOpenChange: onOpenChange, children: _jsxs(DialogContent, { className: cn(placement === 'fullscreen'
+                            ? 'h-[95vh] w-full max-w-[98vw] overflow-y-auto'
+                            : SIZE_CLASS[d.size || 'default']), children: [d.title && (_jsxs(DialogHeader, { children: [_jsx(DialogTitle, { children: d.title }), d.description && _jsx(DialogDescription, { children: d.description })] })), _jsx("div", { children: body }), !d.content && (_jsx("div", { className: "flex justify-end", children: _jsx(Button, { onClick: () => close({ success: true }), children: "OK" }) }))] }) }));
+            }
+        }
+    }
+    return { modalHandler, modalElement, closeModal: close };
+}

package/dist/hooks/useChatConversation.d.ts

@@ -1,11 +1,13 @@
 /** Minimal UIMessage shape compatible with `@ai-sdk/react`'s `useChat`. */
+export interface HydratedUIMessagePart {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}
 export interface HydratedUIMessage {
     id: string;
     role: 'user' | 'assistant' | 'system';
-    parts: Array<{
-        type: 'text';
-        text: string;
-    }>;
+    parts: HydratedUIMessagePart[];
 }
 export interface UseChatConversationOptions {
     /** Authenticated user id; hook is inert until this is defined. */
@@ -27,12 +29,143 @@ export interface UseChatConversationOptions {
      * original cache-first / create-on-miss behaviour.
      */
     activeId?: string;
+    /**
+     * Explicit "start a NEW conversation" intent (the sidebar's New button,
+     * `/ai?new=1`). Without it a bare `/ai` visit resumes the last cached
+     * conversation — which is right for a plain visit but made the New button a
+     * no-op: the resolved-once guard kept the current id and the URL-mirroring
+     * effect immediately rewrote `/ai` back to `/ai/:currentId`. When true (and
+     * no `activeId`), the cache and the guard are skipped and a fresh
+     * conversation is created. Ignored while `activeId` is set.
+     */
+    forceNew?: boolean;
 }
 export interface UseChatConversationReturn {
     conversationId: string | undefined;
+    /**
+     * The `scope` (agent) the current `conversationId` was resolved under. Lets a
+     * host distinguish "this id belongs to the active agent" from "this id is the
+     * PREVIOUS agent's, pending re-resolution after a switch" — so it doesn't
+     * mirror a stale id onto the new agent's URL.
+     */
+    conversationScope: string | undefined;
     initialMessages: HydratedUIMessage[];
     isLoading: boolean;
     /** Delete the current conversation + start a fresh one. */
     reset: () => Promise<void>;
 }
+/**
+ * The subset of plugin-chatbot's `DraftReview` (mapMessages.ts) that the chat's
+ * draft/publish + ADR-0038 verification cards are derived from. Mirrored here —
+ * rather than imported — to keep this low-level hook free of a `@object-ui/
+ * plugin-chatbot` dependency; the round-trip test in
+ * `useChatConversation.test.tsx` runs these through the REAL detectors, so any
+ * incompatible drift fails CI.
+ */
+interface CachedDraftReview {
+    items: Array<{
+        type: string;
+        name: string;
+    }>;
+    summary?: string;
+    packageId?: string;
+    autoPublishable?: boolean;
+    failedCount?: number;
+    materialized?: boolean;
+    verification?: {
+        errors: number;
+        warnings: number;
+    };
+    issues?: Array<{
+        severity: 'error' | 'warning';
+        code: string;
+        message: string;
+        fix?: string;
+    }>;
+    nextSteps?: string[];
+}
+/** Mirrors the subset of plugin-chatbot's `ProposedPlan` the "Proposed plan" card needs. */
+interface CachedProposedPlan {
+    summary?: string;
+    objects: Array<{
+        name: string;
+        label?: string;
+        fieldCount: number;
+    }>;
+    counts: {
+        objects: number;
+        views: number;
+        dashboards: number;
+        seedData: number;
+    };
+    questions: string[];
+    assumptions: string[];
+    targetApp?: string;
+}
+interface CacheableChatToolInvocation {
+    toolCallId: string;
+    toolName: string;
+    state?: string;
+    errorText?: string;
+    /**
+     * The detect-relevant shapes the live render already derived from the tool
+     * result (`uiMessageToChatMessage`). Present on assistant tool invocations
+     * that staged a draft (`apply_blueprint` …) or proposed a plan
+     * (`propose_blueprint`). We re-serialize these into a COMPACT tool `output`
+     * so the cards survive a cache-fallback reload — see
+     * `sanitizeChatMessagesForCache`.
+     */
+    draftReview?: CachedDraftReview;
+    proposedPlan?: CachedProposedPlan;
+}
+interface CacheableChatMessage {
+    id: string;
+    role: 'user' | 'assistant' | 'system';
+    content?: string;
+    toolInvocations?: CacheableChatToolInvocation[];
+}
+export declare function writeConversationMessagesCache(conversationId: string | undefined, messages: HydratedUIMessage[]): void;
+export declare function sanitizeChatMessagesForCache(messages: CacheableChatMessage[]): HydratedUIMessage[];
+interface ServerMessage {
+    id?: string;
+    role: string;
+    content: unknown;
+}
+interface ServerConversation {
+    id: string;
+    messages?: ServerMessage[];
+}
+export declare function toUIMessages(rows: ServerMessage[] | undefined): HydratedUIMessage[];
+/**
+ * A FLAT `ai_messages` row as returned by the public share endpoint
+ * (`GET /api/v1/share-links/:token/messages`), which streams the raw object
+ * rows rather than the reconstructed ModelMessage history that the
+ * authenticated `GET /conversations/:id` returns.
+ */
+export interface RawAiMessageRow {
+    id?: string;
+    role: string;
+    /** Persisted text (assistant/user/system) OR a JSON-stringified tool-result array (tool role). */
+    content?: unknown;
+    /** Assistant tool CALLS, JSON-stringified (`tool-call` parts). */
+    tool_calls?: string | null;
+    /** Tool RESULT's owning call id (legacy plain-string tool rows). */
+    tool_call_id?: string | null;
+}
+/**
+ * Reconstruct the ModelMessage-shaped `content` that {@link toUIMessages}
+ * expects from the FLAT columns the public share endpoint returns raw.
+ *
+ * The authenticated path gets this reconstruction server-side
+ * (`ObjqlConversationService.toMessage`): an assistant turn's tool CALLS live
+ * in the separate `tool_calls` column, and a `tool` row's RESULTS are a
+ * JSON-stringified array in `content`. The share endpoint skips that step and
+ * dumps the rows verbatim — so the shared transcript previously rendered the
+ * raw `{"type":"tool-result",…}` envelope as text instead of a card. Mirroring
+ * `toMessage` here lets the share page reuse the exact same hydrate → render
+ * pipeline as the live chat. Keep this in lockstep with `toMessage`.
+ */
+export declare function aiMessageRowsToServerMessages(rows: RawAiMessageRow[] | undefined): ServerMessage[];
+export declare function fetchConversation(apiBase: string, id: string): Promise<ServerConversation | null>;
 export declare function useChatConversation(options: UseChatConversationOptions): UseChatConversationReturn;
+export {};