@llmnative/react 1.1.0 → 1.2.0

package/dist/types/src/I18n.d.ts

@@ -57,6 +57,9 @@ export interface I18nDict {
         delete: string;
         cancel: string;
         close: string;
+        ok: string;
+        yes: string;
+        no: string;
     };
     upload: {
         clickOrDrag: string;

package/dist/types/src/components/ErrorBoundary.d.ts

@@ -25,6 +25,6 @@ declare class ErrorBoundary extends React.Component<ErrorBoundaryProps, State> {
     reset: () => void;
     copy: () => void;
     sendReport: () => void;
-    render(): string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;
+    render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
 }
 export default ErrorBoundary;

package/dist/types/src/components/blocks/Dropdown.d.ts

@@ -7,7 +7,7 @@ interface DropdownTogglerProps {
     text?: string;
     title?: string;
 }
-interface DropdownProps extends MotionUIProps {
+export interface DropdownProps extends MotionUIProps {
     children: React.ReactNode;
     /** Dropdown trigger: string (label), React element, or `DropdownTogglerProps` object. */
     trigger?: string | React.ReactNode | DropdownTogglerProps;
@@ -34,6 +34,26 @@ interface DropdownProps extends MotionUIProps {
     headerClassName?: string;
     footerClassName?: string;
 }
+export type AsyncDropdownLoader<TItem> = (query: string, signal: AbortSignal) => Promise<TItem[]>;
+export interface AsyncDropdownProps<TItem> extends Omit<DropdownProps, 'children' | 'header' | 'onOpenChange'> {
+    /** Loads results when the menu opens and whenever the query changes. */
+    loadItems: AsyncDropdownLoader<TItem>;
+    getItemId: (item: TItem) => string;
+    renderItem: (item: TItem) => React.ReactNode;
+    /** Return `false` to keep the menu open (for example after a declined confirmation). */
+    onSelect: (item: TItem) => void | boolean | Promise<void | boolean>;
+    selectedId?: string | null;
+    searchPlaceholder?: string;
+    emptyState?: React.ReactNode;
+    loadingState?: React.ReactNode;
+    errorState?: (error: unknown) => React.ReactNode;
+    debounceMs?: number;
+    closeOnSelect?: boolean;
+    inputClassName?: string;
+    selectedClassName?: string;
+    header?: React.ReactNode;
+    onOpenChange?: (open: boolean) => void;
+}
 interface DropdownButtonProps extends Pick<MotionUIProps, 'motion'> {
     children: React.ReactNode;
     badge?: BadgeProps;
@@ -45,7 +65,7 @@ interface DropdownButtonProps extends Pick<MotionUIProps, 'motion'> {
     onToggle?: () => void;
     open?: boolean;
     menuId?: string;
-    buttonRef?: React.RefObject<HTMLButtonElement>;
+    buttonRef?: React.RefObject<HTMLButtonElement | null>;
 }
 interface DropdownItemProps {
     /** Link URL. When set, renders as `<a>`, otherwise as `<button>`. */
@@ -64,6 +84,11 @@ interface DropdownDividerProps {
     className?: string;
 }
 export declare const Dropdown: ({ children, trigger, badge, header, footer, defaultOpen, open: controlledOpen, onOpenChange, staticOpen, position, placement, strategy, wrapperClassName, className, before, after, triggerClassName, menuClassName, badgeClassName, headerClassName, footerClassName, motion: motionConfig, }: DropdownProps) => React.JSX.Element;
+/**
+ * Async/searchable extension of Dropdown. It owns only the interaction model; applications
+ * supply their own data reader and selection action (site, tenant, entity, or any resource).
+ */
+export declare function AsyncDropdown<TItem>({ loadItems, getItemId, renderItem, onSelect, selectedId, searchPlaceholder, emptyState, loadingState, errorState, debounceMs, closeOnSelect, inputClassName, selectedClassName, header, open: controlledOpen, defaultOpen, onOpenChange, footer, headerClassName, staticOpen, ...dropdownProps }: AsyncDropdownProps<TItem>): React.JSX.Element;
 export declare const DropdownButton: ({ children, badge, display, className, badgeClassName, motion: motionConfig, title, onToggle, open, menuId, buttonRef }: DropdownButtonProps) => React.JSX.Element;
 export declare const DropdownItem: ({ children, url, onClick, icon, className }: DropdownItemProps) => React.JSX.Element;
 export declare const DropdownHeader: ({ children, className }: DropdownHeaderProps) => React.JSX.Element;

package/dist/types/src/components/ui/Alert.d.ts

@@ -16,7 +16,7 @@ export type AlertProps = {
      */
     placement?: "inline" | "fixed" | "sticky";
     /** Required when placement="sticky": the scrollable container to anchor to. */
-    anchorRef?: React.RefObject<HTMLElement>;
+    anchorRef?: React.RefObject<HTMLElement | null>;
     /** Auto-dismiss timeout in ms. */
     timeout?: number;
     /** Called when the alert is dismissed. */

package/dist/types/src/components/ui/Gallery.d.ts

@@ -26,6 +26,12 @@ export type GalleryOverlay = {
     render?: (item: GalleryRecord, index: number) => React.ReactNode;
     when?: GalleryOverlayFilter;
     className?: string;
+    /**
+     * Inline style overrides, merged on top of the position's own offset styles (and, for
+     * `width`/`maxWidth`, on top of the default overlay lane width — a single-line badge's
+     * width, too narrow for e.g. a multi-line description meant to span most of the card).
+     */
+    style?: React.CSSProperties;
 };
 export type GallerySelectionState = RecordSelectionState<GalleryRecord>;
 export type GallerySelectionChangeHandler = (selection: GallerySelectionState) => void;

package/dist/types/src/components/ui/Loader.d.ts

@@ -9,5 +9,5 @@ interface LoaderProps extends UIProps {
     title?: string;
     description?: string;
 }
-declare function Loader({ children, show, icon, title, description, before, after, wrapperClassName, className }: LoaderProps): string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;
+declare function Loader({ children, show, icon, title, description, before, after, wrapperClassName, className }: LoaderProps): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
 export default Loader;

package/dist/types/src/components/ui/Modal.d.ts

@@ -40,6 +40,15 @@ export interface ModalProps extends MotionUIProps {
     closeOnBackdrop?: boolean;
     /** CSS `z-index` override (useful when stacking modals). */
     zIndex?: number;
+    /**
+     * Px of screen space already reserved on the right edge (e.g. a persistent app-level
+     * side panel docked outside this Modal's own portal) — the backdrop/cover stop short of
+     * that space (so the reserved area stays undimmed and interactive) and, for
+     * `position="right"`, the dialog itself shifts left by the same amount instead of
+     * overlapping it. `0`/`undefined` = today's behaviour, flush against the real viewport
+     * edge.
+     */
+    rightInset?: number;
     /**
      * When `true` this modal is visually "behind" another modal stacked on top.
      * The panel becomes 10% wider (so its edge peeks out from behind the upper modal),
@@ -47,6 +56,15 @@ export interface ModalProps extends MotionUIProps {
      * modal's backdrop handles interaction blocking), and its cover becomes non-interactive.
      */
     stackedBehind?: boolean;
+    /**
+     * Replaces the default × close button with custom content, in the same header slot
+     * (still next to the fullscreen toggle, if any). Use this when the host app wants one
+     * consistent icon/action across every modal instead of the built-in ×  — e.g. an
+     * app-level "toggle side panel" icon that means the same thing whether a modal happens
+     * to be open or not. Backdrop click and Cancel/Save/Delete still call `onClose` as usual;
+     * this only swaps what's rendered in the × slot, not the close mechanics themselves.
+     */
+    closeSlot?: React.ReactNode;
 }
 /** Props for a confirm/deny modal dialog with Yes/No buttons. */
 export interface ModalYesNoProps {

package/dist/types/src/components/ui/Tab.d.ts

@@ -41,7 +41,7 @@ interface TabProps extends MotionUIProps {
 export declare function getTabLayoutConfig(layout: TabPosition): TabLayoutConfig;
 export declare function getTabTriggerClassName(layout: TabPosition, active: boolean, className?: string): string;
 export declare function getTabPaneClassName(className?: string): string;
-export declare const TabLayouts: Record<TabPosition, (props: TabLayoutProps) => JSX.Element>;
+export declare const TabLayouts: Record<TabPosition, (props: TabLayoutProps) => React.ReactElement>;
 export declare const TabItem: React.FC<TabItemProps>;
 declare const Tab: React.FC<TabProps>;
 export default Tab;

package/dist/types/src/components/ui/fields/CodeEditor.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 import { FormFieldProps } from '../../widgets/Form';
+import { type EditorHeight } from '../../../libs/editorHeight';
 import type { FieldValue } from '../../../providers/data/DataProvider';
 import { type EditorCommand } from './ContextMenu';
 export type CodeEditorLanguage = 'liquid' | 'html' | 'json' | 'js' | 'ts' | 'css';
@@ -29,7 +30,11 @@ export declare const getCodeValidationResult: (code: string, language: CodeEdito
 export interface CodeEditorProps extends FormFieldProps {
     language?: CodeEditorLanguage;
     placeholder?: string;
-    minHeight?: number;
+    /** A pixel value, or `'fill'` to stretch to the parent container's height (with the
+     * editor's own internal scroll) instead of a fixed size — see `EditorHeight`. The
+     * parent must actually provide a real height (e.g. a flex column with `flex-1 min-h-0`)
+     * for `'fill'` to have any effect. */
+    minHeight?: EditorHeight;
     maxHeight?: number;
     label?: string;
     required?: boolean;

package/dist/types/src/components/ui/fields/ContextMenu.d.ts

@@ -4,6 +4,8 @@ export interface ContextMenuItem {
     label: string;
     value: string;
     icon?: string;
+    /** Secondary muted text under the label — e.g. a variable's description/type. */
+    description?: string;
 }
 export interface EditorContext {
     value: string;
@@ -29,6 +31,14 @@ export interface EditorCommand {
     name: string;
     description?: string;
     icon?: string;
+    /** Groups commands under a `ContextMenu.Heading` in menu order — commands sharing the
+     * same `group` string render contiguously under one heading (see CodeEditor.tsx's
+     * `commandMenuItems`/render logic, which does the grouping/heading-insertion). Commands
+     * without a `group` render ungrouped, in their original order. */
+    group?: string;
+    /** Optional auto-closed suffix to consume when replacing the active trigger. Useful when
+     * a command changes syntactic family, for example from `{{ ... }}` to `{% ... %}`. */
+    consumeSuffix?: string;
     handler?: (context: TextCommandContext) => string | Promise<string>;
 }
 export interface ContextMenuControlledState {
@@ -59,6 +69,8 @@ interface ContextMenuItemProps extends UIProps {
     label: string;
     value: string;
     icon?: string;
+    /** Secondary muted text under the label — e.g. a variable's description/type. */
+    description?: string;
 }
 interface ContextMenuHeadingProps {
     children: React.ReactNode;
@@ -81,6 +93,18 @@ type CommandTriggerMatchOptions = {
     queryPattern?: RegExp;
     requireWhitespacePrefix?: boolean;
 };
+/**
+ * Whether `textAfterCaret` (from `TextCommandContext`/`EditorContext`) already starts with
+ * `closer`, optionally preceded by whitespace — typically because the editor's own
+ * bracket/quote auto-closing inserted it when the user typed the opening one. A command
+ * `handler` that would otherwise insert a closer of its own (e.g. `"{{ x }}"`) should check
+ * this first and omit its own closer when true, to avoid a duplicate
+ * (`"{{ x }}}}"` instead of the intended `"{{ x }}"`).
+ */
+export declare const hasAutoClosedSuffix: (textAfterCaret: string, closer: string) => boolean;
+/** Returns the number of characters occupied by an auto-closed suffix, including whitespace
+ * before it, or zero when the requested suffix is not present. */
+export declare const getAutoClosedSuffixLength: (textAfterCaret: string, closer: string) => number;
 export declare const matchCommandTrigger: (value: string, caret: number, trigger: string, options?: CommandTriggerMatchOptions) => QueryMatch | null;
 export declare const buildTextCommandContext: (context: EditorContext) => TextCommandContext;
 declare const ContextMenu: ContextMenuComponent;

package/dist/types/src/components/ui/fields/Upload.d.ts

@@ -41,7 +41,7 @@ export interface UseFileUploadCoreOptions {
 export declare const useFileUploadCore: ({ onFilesChange, onFileReady, uploadPath, srcsetWidths, initialFiles, storageKey, storageProvider, }: UseFileUploadCoreOptions) => {
     files: FileProps[];
     setFiles: React.Dispatch<React.SetStateAction<FileProps[]>>;
-    fileInputRef: React.MutableRefObject<HTMLInputElement | null>;
+    fileInputRef: React.RefObject<HTMLInputElement | null>;
     updateFile: (key: string, updates: Partial<FileProps>) => void;
     handleFiles: (selectedFiles: File[]) => void;
     handleUpload: () => void | undefined;

package/dist/types/src/components/widgets/Form.d.ts

@@ -118,11 +118,14 @@ interface BaseFormProps {
     log?: boolean;
     /** Show the inline save/delete notice banner. Defaults to `true`. */
     showNotice?: boolean;
-    /** Persist unsaved changes locally and offer restore/discard on re-entry. Defaults to `false`. */
-    persistDraft?: boolean;
+    /**
+     * Stable bucket that isolates this form's local draft. Omit to disable draft persistence.
+     * The Form appends its own path/route identity, so one bucket safely serves many forms.
+     */
+    draftBucket?: string;
     /** When provided, the save/delete notice is rendered sticky at the top of this container
      *  instead of inline in the form footer. Ideal for full-page forms outside a modal. */
-    noticeAnchorRef?: React.RefObject<HTMLElement>;
+    noticeAnchorRef?: React.RefObject<HTMLElement | null>;
     /** Render a Back navigation button in the footer. */
     showBack?: boolean;
     /** CSS classes on the outermost wrapper element. */
@@ -133,6 +136,14 @@ interface BaseFormProps {
     className?: string;
     /** CSS classes on the footer container. */
     footerClassName?: string;
+    /**
+     * CSS classes on the native `<form>` element itself — distinct from `wrapperClassName`
+     * (the outer `Wrapper` div) and `className` ("card" appearance's body). Needed whenever
+     * a layout must cascade real height/flex context through the form (e.g. a full-height
+     * field like `CodeEditor`'s `minHeight="fill"`) instead of reaching in via an arbitrary
+     * `[&>form]:` child selector on `wrapperClassName`.
+     */
+    formClassName?: string;
 }
 interface FormDefaultProps extends BaseFormProps {
     children: React.ReactNode | ((fields: FormTree) => React.ReactNode) | ((args: {

package/dist/types/src/components/widgets/grid-core/GridCore.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
 import { type RecordProps } from "../../../providers/data/DataProvider";
 import { type GridCoreProps } from "./types";
-declare function GridCore<TRecord extends RecordProps>({ records, recordId, sourcePath, columns, actions, form, editDeepLink, header, footer, view, sticky, wrapperClassName, loading, title, before, after, sortable, pagination, selection, onRowClick, reorderable, onReorder, groupBy, onSave, onDelete, onComplete, audit, onLoad, }: GridCoreProps<TRecord>): React.JSX.Element;
+declare function GridCore<TRecord extends RecordProps>({ records, recordId, sourcePath, columns, actions, form, editDeepLink, header, footer, view, views, sticky, wrapperClassName, loading, title, before, after, sortable, pagination, selection, onRowClick, reorderable, onReorder, groupBy, onSave, onDelete, onComplete, audit, onLoad, }: GridCoreProps<TRecord>): React.JSX.Element;
 export default GridCore;

package/dist/types/src/components/widgets/grid-core/GridGalleryView.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
 import { type RecordProps } from "../../../providers/data/DataProvider";
 import { type GridGalleryViewProps } from "./types";
-declare function GridGalleryView<TRecord extends RecordProps>({ records, recordId, sortable, pagination, selection, selectedKeys, onSelectionChange, onRowClick, groupBy, wrapperClassName, before, after, }: GridGalleryViewProps<TRecord>): React.JSX.Element;
+declare function GridGalleryView<TRecord extends RecordProps>({ records, recordId, sortable, pagination, selection, selectedKeys, onSelectionChange, onRowClick, groupBy, wrapperClassName, before, after, columns, overlays, }: GridGalleryViewProps<TRecord>): React.JSX.Element;
 export default GridGalleryView;

package/dist/types/src/components/widgets/grid-core/types.d.ts

@@ -1,11 +1,70 @@
 import React from "react";
 import { type OrderConfig } from "../../../libs/order";
 import { type PaginationParams } from "../../ui/Pagination";
+import { type GalleryOverlay } from "../../ui/Gallery";
 import { type DatabaseOptions, type RecordProps } from "../../../providers/data/DataProvider";
 export type GridLayout = "table" | "gallery";
 export type GridSticky = "top" | "bottom";
 export type GridSelectionMode = false | "single" | "multiple";
 export type GridRecordKey<TRecord> = keyof TRecord | ((record: TRecord) => string);
+/**
+ * Declarative field shown as an overlay on a gallery card — distinct from `GridColumn`
+ * (which drives table columns): a card doesn't need the same fields as a table row,
+ * and has its own visibility picker (`views.gallery.fieldPicker`) separate from the
+ * table's `views.table.columnPicker`.
+ */
+export type GridGalleryField<TRecord> = {
+    /** Record field to read. Accepts dot-notation strings for nested fields. */
+    key: keyof TRecord | string;
+    /** Label shown in the field picker (not on the card itself — the card shows the value only). */
+    label: string;
+    /** Where on the card this field's value is overlaid. Defaults to `"bottomLeft"`. */
+    position?: "topLeft" | "topRight" | "bottomLeft" | "bottomRight" | "middleLeft" | "middleRight";
+    /** Whether this field is shown by default when `fieldPicker` is enabled. Defaults to `true`. */
+    defaultVisible?: boolean;
+    /** Custom render — defaults to the raw field value as text. */
+    render?: (value: unknown, record: TRecord) => React.ReactNode;
+};
+/** Table-specific view options, grouped under `views.table`. */
+export type GridTableViewConfig = {
+    /** Show a built-in "Columns" dropdown letting the user show/hide table columns. Default `false`. */
+    columnPicker?: boolean;
+};
+/** Gallery-specific view options, grouped under `views.gallery`. */
+export type GridGalleryViewConfig<TRecord> = {
+    /** Cards per row — one of `1|2|3|4|6` (the only values the underlying `Gallery` component supports). */
+    columns?: 1 | 2 | 3 | 4 | 6;
+    /**
+     * Declarative fields overlaid on each card (see `GridGalleryField`). Generates the
+     * overlays automatically and, combined with `fieldPicker`, a "Fields" dropdown
+     * analogous to the table's "Columns" picker — but a separate one, since a card
+     * typically shows fewer/different fields than a table row.
+     */
+    fields?: GridGalleryField<TRecord>[];
+    /** Show the built-in "Fields" dropdown for `fields` above. Default `false`. */
+    fieldPicker?: boolean;
+    /**
+     * Escape hatch: fully custom overlay renderers (forwarded to `<Gallery overlays>`),
+     * for anything `fields` can't express (e.g. an action button, not just a label).
+     * ADDITIVE to the overlays generated from `fields` — a caller commonly needs both at
+     * once (e.g. a Delete button plus checkable label fields); positions shared by both
+     * simply stack, with the custom overlay rendered first.
+     */
+    overlays?: GalleryOverlay[];
+};
+/**
+ * Groups every Table/Gallery-view-switching concern under one input, instead of a flat
+ * spray of booleans on `<Grid>` — `toggle` decides whether the switch exists at all,
+ * `table`/`gallery` hold the options specific to each view (column picker vs. field
+ * picker are deliberately two different controls, since a gallery card and a table row
+ * don't need to show the same fields).
+ */
+export type GridViewsConfig<TRecord> = {
+    /** Show the built-in Table/Gallery switch in the header, letting the user change the active view at runtime. Default `false` — `view` behaves as a fixed initial mode when omitted, same as before this existed. */
+    toggle?: boolean;
+    table?: GridTableViewConfig;
+    gallery?: GridGalleryViewConfig<TRecord>;
+};
 export type GridFormat = "text" | "email" | "date" | "datetime" | "badge" | "image" | "boolean" | "json";
 export type GridCellContext<TRecord> = {
     record: TRecord;
@@ -30,6 +89,8 @@ export type GridColumn<TRecord> = {
     className?: string;
     /** Built-in format name or custom render function. */
     render?: GridFormat | ((ctx: GridCellContext<TRecord>) => React.ReactNode);
+    /** Whether this column is shown by default when `views.table.columnPicker` is enabled. Defaults to `true`. */
+    defaultVisible?: boolean;
 };
 export type GridSelectionState<TRecord> = {
     keys: string[];
@@ -150,9 +211,11 @@ export type GridAfterActionArgs<TRecord> = {
 };
 export type GridAfterActionHandler<TRecord> = (args: GridAfterActionArgs<TRecord>) => Promise<boolean>;
 /** Visual / layout props for `<Grid>`. */
-export type GridPresentation = {
-    /** Display mode: `"table"` (default) or `"gallery"` card layout. */
+export type GridPresentation<TRecord> = {
+    /** Display mode: `"table"` (default) or `"gallery"` card layout. Acts as the initial/default view — see `views.toggle` to let the user switch at runtime. */
     view?: GridLayout;
+    /** Table/Gallery switch + per-view options (column picker, gallery field picker, cards-per-row, …) — see `GridViewsConfig`. Omit entirely to keep the pre-existing fixed-`view` behavior. */
+    views?: GridViewsConfig<TRecord>;
     /** Stick the header (`"top"`) or footer (`"bottom"`) while scrolling. */
     sticky?: GridSticky;
     /** CSS classes on the outermost wrapper element. */
@@ -198,7 +261,7 @@ export type GridPersistence<TRecord> = {
  * Full prop surface shared by all `<Grid>` variants.
  * Combines presentation, behaviour, and persistence with a few top-level hooks.
  */
-export type GridBaseProps<TRecord> = GridPresentation & GridBehavior<TRecord> & GridPersistence<TRecord> & {
+export type GridBaseProps<TRecord> = GridPresentation<TRecord> & GridBehavior<TRecord> & GridPersistence<TRecord> & {
     /** Transform the record array after loading (filter, sort, enrich). */
     onLoad?: (records: TRecord[]) => TRecord[] | Promise<TRecord[]>;
     /** Column definitions. Omit to auto-generate from record keys. */
@@ -222,6 +285,15 @@ export type GridCoreProps<TRecord extends RecordProps> = GridBaseProps<TRecord>
 export type GridArrayProps<TRecord extends RecordProps> = GridBaseProps<TRecord> & {
     records: TRecord[];
     recordId: GridRecordKey<TRecord>;
+    /**
+     * Base path the `records` were sourced from (e.g. `/components`) — enables the built-in
+     * "delete" action's `db.remove(\`${sourcePath}/${recordKey}\`)` when the caller fetched
+     * its own records (e.g. via `db.subscribe()`) instead of letting Grid fetch them itself
+     * (`GridDBProps.path` does the equivalent there). Already threaded through to `GridCore`
+     * — this was just missing from the public prop surface for the `records` variant.
+     * Omit if delete is handled entirely via a custom `actions.delete`/`onDelete`.
+     */
+    sourcePath?: string;
 };
 export type GridDBQuery = Pick<DatabaseOptions, "where" | "order" | "fieldMap">;
 export type GridDBPath = string;
@@ -273,5 +345,9 @@ export type GridGalleryViewProps<TRecord extends RecordProps> = {
     wrapperClassName?: string;
     before?: React.ReactNode;
     after?: React.ReactNode;
+    /** Cards per row — forwarded to `<Gallery columns>`. */
+    columns?: 1 | 2 | 3 | 4 | 6;
+    /** Overlay badges/render-props for each card — forwarded to `<Gallery overlays>`. */
+    overlays?: GalleryOverlay[];
 };
 export {};

package/dist/types/src/components/widgets/grid-core/useGridActions.d.ts

@@ -31,7 +31,7 @@ declare function useGridActions<TRecord extends RecordProps>({ actions, form, ed
     normalizedActions: Record<string, GridAction<TRecord>>;
     activeAction: GridActiveAction<TRecord> | null;
     activeActionConfig: GridAction<TRecord> | undefined;
-    activeActionBody: string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;
+    activeActionBody: string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
     activeKey: string | null;
     runAction: (actionKey: string, record?: TRecord) => Promise<void>;
     runModalAction: (actionKey: string) => Promise<void>;

package/dist/types/src/index.d.ts

@@ -21,7 +21,7 @@ export { PromptUtils } from './libs/promptUtils';
 export type { PromptAction, PromptStatusItem, PromptRunStats } from './components/widgets/Prompt';
 export type { TableHeaderProp, TableReorderHandler, TableReorderMeta, TableSelectionChangeHandler, TableSelectionState } from './components/ui/Table';
 export type { GalleryRecord, GallerySelectionChangeHandler, GallerySelectionState } from './components/ui/Gallery';
-export type { GridAction, GridActions, GridAfterActionArgs, GridAfterActionHandler, GridArrayProps, GridColumn, GridCoreProps, GridDBPath, GridDBQuery, GridDBProps, GridFooterContext, GridFormContext, GridGalleryViewProps, GridHeaderContext, GridLayout, GridMutationDeleteArgs, GridMutationDeleteHandler, GridMutationSaveArgs, GridMutationSaveHandler, GridReorderHandler, GridReorderMeta, GridRecordKey, GridProps, GridSelectionChangeHandler, GridSelectionMode, GridSelectionState, GridSticky, GridTableViewProps, GridCellContext, } from './components/widgets/Grid';
+export type { GridAction, GridActions, GridAfterActionArgs, GridAfterActionHandler, GridArrayProps, GridColumn, GridCoreProps, GridDBPath, GridDBQuery, GridDBProps, GridFooterContext, GridFormContext, GridGalleryField, GridGalleryViewProps, GridGalleryViewConfig, GridHeaderContext, GridLayout, GridMutationDeleteArgs, GridMutationDeleteHandler, GridMutationSaveArgs, GridMutationSaveHandler, GridReorderHandler, GridReorderMeta, GridRecordKey, GridProps, GridSelectionChangeHandler, GridSelectionMode, GridSelectionState, GridSticky, GridTableViewProps, GridTableViewConfig, GridViewsConfig, GridCellContext, } from './components/widgets/Grid';
 export type { ProviderConfigurable, ProviderConfigurationState } from './providers/ProviderConfiguration';
 export { getProviderConfigurationState } from './providers/ProviderConfiguration';
 export type { ProviderAdapterMap, ProviderService, SetProviderFn, ProviderRegistrySnapshot } from './providers/ProviderRegistryContext';
@@ -75,7 +75,7 @@ export { IconProvider, useIconProvider, useIconController } from './providers/ic
 export type { AppIconProviderConfig, IconController } from './providers/icon/IconProviderContext';
 export { useEmailProvider, EmailProvider } from './providers/email/EmailProviderContext';
 export { GmailEmailProvider } from './providers/email/google/GmailEmailProvider';
-export type { AIRequestOptions, AIAttachment, AIProviderAdapter, AIKeyValidationResult, AIModelDescriptor, AIProviderCapabilities, AIModelCatalog, AIProviderDefinition } from './providers/ai';
+export type { AIRequestOptions, AIAttachment, AIProviderAdapter, AIKeyValidationResult, AIModelDescriptor, AIProviderCapabilities, AIModelCatalog, AIProviderDefinition, AICompleteRequest, AICompleteResult, AIConversationTurn, AIToolDefinition, AIToolCall, AIToolResult, } from './providers/ai';
 export { createAIProviderRegistry, getAIModelCatalog, formatAIModelRef, parseAIModelRef, AI_PROVIDER_DEFINITIONS, AI_PROVIDER_DESCRIPTORS, OPENAI_COMPATIBLE_PROVIDER_DESCRIPTOR, toProviderDescriptor } from './providers/ai';
 export type { ProviderDescriptor, ProviderCredentialField } from './providers/ProviderDescriptor';
 export { useAIProvider, useAIProviderRegistry, AIProvider } from './providers/ai/AIProviderContext';

package/dist/types/src/libs/editorHeight.d.ts

@@ -1,9 +1,19 @@
+/**
+ * `'fill'` means "stretch to the height of whatever parent container you're placed in,
+ * instead of a fixed pixel height" — the parent must actually provide a real height (e.g.
+ * a flex column with `flex-1 min-h-0`) for this to have any effect; on an auto-height
+ * parent it resolves to the same as not being there.
+ */
+export type EditorHeight = number | 'fill';
 export interface EditorHeightOptions {
-    minHeight?: number;
+    minHeight?: EditorHeight;
     maxHeight?: number;
     paddingOffset?: number;
 }
 export interface EditorHeightResult {
+    /** True when `minHeight === 'fill'` — the editor stretches to its parent's height with
+     * its own internal scroll, instead of using a fixed pixel min-height. */
+    fill: boolean;
     adjustedMinHeight: number;
     wrapperStyle: React.CSSProperties;
     resolvedMinHeight: number;

package/dist/types/src/libs/fetch.d.ts

@@ -2,6 +2,8 @@ interface FetchOptions {
     method?: "GET" | "POST" | "PUT" | "DELETE" | "HEAD" | "PATCH";
     headers?: Record<string, string>;
     body?: Record<string, unknown> | string;
+    /** Lets a caller cancel an in-flight request (e.g. a "stop" button on a long AI call). */
+    signal?: AbortSignal;
 }
 export declare function fetchRest(url: string, options?: FetchOptions | null, fetchFn?: typeof fetch): Promise<any>;
 export declare function fetchJson(url: string, options?: FetchOptions | null, fetchFn?: typeof fetch): Promise<any>;

package/dist/types/src/providers/ai/AIProvider.d.ts

@@ -27,10 +27,63 @@ export interface AIRequestOptions {
     temperature?: number;
     attachments?: AIAttachment[];
 }
+/** Definizione di un tool che il modello può scegliere di invocare — la SDK del provider
+ * riceve solo questa forma (JSON-serializzabile); l'implementazione vera resta lato
+ * chiamante (mai inviata al provider). Vedi AICompleteResult per come il modello segnala
+ * una richiesta di invocazione. */
+export interface AIToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+/** Richiesta del modello di invocare un tool con questi argomenti — il chiamante esegue
+ * `name` localmente e rimanda il risultato come AIToolResult nel turno successivo. */
+export interface AIToolCall {
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+/** Esito dell'esecuzione locale di un tool, da rimandare al modello nel turno successivo. */
+export interface AIToolResult {
+    toolCallId: string;
+    name: string;
+    output: unknown;
+    isError?: boolean;
+}
+/** Un turno della conversazione precedente a quello corrente — passato via
+ * `AICompleteRequest.history` per continuare una chat multi-turno (es. l'utente affina una
+ * richiesta AI già eseguita, o il modello ha invocato un tool e ne riceve il risultato). */
+export type AIConversationTurn = {
+    role: 'user';
+    content: string;
+} | {
+    role: 'assistant';
+    content?: string;
+    toolCalls?: AIToolCall[];
+} | {
+    role: 'tool_result';
+    results: AIToolResult[];
+};
 export interface AICompleteRequest extends AIRequestOptions {
     prompt: string;
     data?: PromptVariables;
+    /** Turni precedenti della conversazione — assente = primo turno (solo `prompt`). */
+    history?: AIConversationTurn[];
+    /** Tool che il modello può invocare a sua discrezione in questo turno. */
+    tools?: AIToolDefinition[];
+    /** Annulla la richiesta in corso (es. un bottone "interrompi" lato chiamante). */
+    signal?: AbortSignal;
 }
+/** Esito di una chiamata completate — testo semplice, oppure una o più richieste di tool
+ * call (eventualmente accompagnate da testo, quando il modello commenta prima di invocare). */
+export type AICompleteResult = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'tool_calls';
+    toolCalls: AIToolCall[];
+    text?: string;
+};
 export interface AIKeyValidationResult {
     valid: boolean;
     /** Human-readable error from the provider API (e.g. "Incorrect API key provided"). */
@@ -45,7 +98,7 @@ export interface AIProviderAdapter extends ProviderConfigurable {
     /** URL to the provider's API key management page. */
     dashboardUrl?: string;
     getCapabilities(forceRefresh?: boolean): Promise<AIProviderCapabilities>;
-    complete(request: AICompleteRequest): Promise<string | null>;
+    complete(request: AICompleteRequest): Promise<AICompleteResult | null>;
     /** Makes a live API call to verify the key is accepted. Never uses cache. */
     validateApiKey(): Promise<AIKeyValidationResult>;
 }

package/dist/types/src/providers/ai/index.d.ts

@@ -2,7 +2,7 @@ import type { AIConfig } from '../../Config';
 import type { ProviderDescriptor } from '../ProviderDescriptor';
 import type { AIProviderAdapter } from './AIProvider';
 import { type AIProviderDefinition } from './shared';
-export type { AIProviderAdapter, AIKeyValidationResult, AIModelDescriptor, AIProviderCapabilities, AIRequestOptions, AIAttachment } from './AIProvider';
+export type { AIProviderAdapter, AIKeyValidationResult, AIModelDescriptor, AIProviderCapabilities, AIRequestOptions, AIAttachment, AICompleteRequest, AICompleteResult, AIConversationTurn, AIToolDefinition, AIToolCall, AIToolResult, } from './AIProvider';
 export { formatAIModelRef, parseAIModelRef } from './AIProvider';
 export type { AIModelCatalog, AIProviderDefinition } from './shared';
 export { getAIModelCatalog } from './shared';

package/dist/types/src/providers/ai/openaiCompatible.d.ts

@@ -1,4 +1,5 @@
 import type { AIProviderDefinition, BuiltInAIProviderId } from './shared';
+import type { AIConversationTurn, AICompleteResult, AIToolDefinition } from './AIProvider';
 type OpenAICompatibleDefinitionOptions = {
     id: BuiltInAIProviderId;
     label: string;
@@ -15,5 +16,26 @@ type OpenAICompatibleDefinitionOptions = {
     /** Override the default validateApiKey when the models endpoint is public or uses a non-standard error format. */
     validateApiKey?: AIProviderDefinition['validateApiKey'];
 };
+/** Esportate per riuso da provider "chat completions"-simili ma non costruiti tramite
+ * createOpenAICompatibleProviderDefinition (vedi opencode.ts) — stesso wire format OpenAI,
+ * niente da reinventare. */
+export declare function toOpenAITool(tool: AIToolDefinition): {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+};
+/** Un turno assistant con tool_calls diventa `tool_calls` sul messaggio assistant; un turno
+ * tool_result diventa un messaggio `role: 'tool'` per ciascun risultato — stessa forma
+ * richiesta dall'API Chat Completions (OpenAI e compatibili) per continuare la conversazione
+ * dopo una tool call. */
+export declare function toOpenAIMessages(turn: AIConversationTurn): Array<Record<string, unknown>>;
+export declare function parseOpenAIResponse(response: {
+    choices?: Array<{
+        message?: Record<string, unknown>;
+    }>;
+} | null): AICompleteResult | null;
 export declare const createOpenAICompatibleProviderDefinition: ({ id, label, description, configKey, requiredConfigKeys, defaultModel, fallbackModels, baseUrl, modelsUrl, chatCompletionsUrl, dashboardUrl, credentialsHint, validateApiKey: validateApiKeyOverride, }: OpenAICompatibleDefinitionOptions) => AIProviderDefinition;
 export {};

package/dist/types/src/providers/ai/shared.d.ts

@@ -1,6 +1,6 @@
 import { type ProviderConfigurationState } from '../ProviderConfiguration';
 import type { ProviderCredentialField } from '../ProviderDescriptor';
-import type { AICompleteRequest, AIKeyValidationResult, AIModelDescriptor, AIProviderAdapter, AIProviderCapabilities, AIRequestOptions } from './AIProvider';
+import type { AICompleteRequest, AICompleteResult, AIKeyValidationResult, AIModelDescriptor, AIProviderAdapter, AIProviderCapabilities, AIRequestOptions } from './AIProvider';
 export type BuiltInAIProviderId = 'openai' | 'openrouter' | 'opencode' | 'openai-compatible' | 'deepseek' | 'gemini' | 'anthropic' | 'mistral' | 'glm';
 export type AIProviderDefinition = {
     id: BuiltInAIProviderId;
@@ -21,7 +21,7 @@ export type AIProviderDefinition = {
     credentialsHint?: string;
     capabilities?: Omit<AIProviderCapabilities, 'models'>;
     discoverModels: (apiKey: string) => Promise<string[]>;
-    complete: (apiKey: string, request: Required<Pick<AICompleteRequest, 'prompt' | 'model'>> & AIRequestOptions) => Promise<string | null>;
+    complete: (apiKey: string, request: Required<Pick<AICompleteRequest, 'prompt' | 'model'>> & AIRequestOptions & Pick<AICompleteRequest, 'history' | 'tools' | 'signal'>) => Promise<AICompleteResult | null>;
     /**
      * Per-provider auth check. When omitted, the default implementation in
      * RuntimeAIProvider calls discoverModels() live (no cache) and treats any
@@ -50,6 +50,6 @@ export declare class RuntimeAIProvider implements AIProviderAdapter {
     isConfigured(): boolean;
     getConfigurationState(): ProviderConfigurationState;
     getCapabilities(forceRefresh?: boolean): Promise<AIProviderCapabilities>;
-    complete(request: AICompleteRequest): Promise<string | null>;
+    complete(request: AICompleteRequest): Promise<AICompleteResult | null>;
     validateApiKey(): Promise<AIKeyValidationResult>;
 }

package/dist/types/src/providers/auth/google/auth.d.ts

@@ -1,3 +1,3 @@
 import { GoogleConfig } from "../../../Config";
 export declare const authConfig: <K extends keyof GoogleConfig>(key: K) => GoogleConfig[K] | undefined;
-export declare const getGoogleCredential: () => import("firebase/auth").OAuthCredential | null;
+export declare const getGoogleCredential: () => import("@firebase/auth").OAuthCredential | null;