@judo/components 0.1.0

package/dist/renderers/TableToolbar.d.ts

@@ -0,0 +1,47 @@
+import { Action } from '@judo/actions';
+import { ConfirmDialogOptions } from '@judo/feedback';
+import { Button as ButtonElement, Column, PageDefinition } from '@judo/model-api';
+import { GridFilterModel, GridPaginationModel, GridSortModel } from '@mui/x-data-grid';
+import { Dispatch, SetStateAction } from 'react';
+export interface TableToolbarProps {
+    buttons: ButtonElement[];
+    testId: string;
+    page?: PageDefinition;
+    hasSelection: boolean;
+    /** Whether this toolbar belongs to an eager table (aggregated element) */
+    isEager?: boolean;
+    /** Action dispatcher function (second arg = context overrides, e.g. selectedRows) */
+    onDispatch?: (action: Action, contextOverrides?: Record<string, unknown>) => Promise<unknown>;
+    /** Currently selected row transfers for bulk operations */
+    selectedRows?: unknown[];
+    /** Setter for the filter button element, used to anchor the filter panel */
+    setFilterButtonEl?: Dispatch<SetStateAction<HTMLButtonElement | null>>;
+    /** Current sort model from DataGrid */
+    sortModel?: GridSortModel;
+    /** Current filter model from DataGrid */
+    filterModel?: GridFilterModel;
+    /** Current pagination model from DataGrid */
+    paginationModel?: GridPaginationModel;
+    /** Table columns for filter conversion */
+    columns?: Column[];
+    /** Whether to count records (for pagination display) */
+    showTotalCount?: boolean;
+    /** Callback to refresh the table after a destructive bulk action (e.g., bulk delete) */
+    onAfterBulkDelete?: () => void;
+    /** Optional confirmation function for destructive actions */
+    confirm?: (options: ConfirmDialogOptions) => Promise<boolean>;
+}
+declare module "@mui/x-data-grid" {
+    interface ToolbarPropsOverrides extends TableToolbarProps {
+    }
+}
+/**
+ * Custom toolbar component for table actions.
+ * Filters buttons by page actions and bulk action requirements.
+ * Used as a DataGrid slots.toolbar component.
+ *
+ * Note: Uses Stack instead of GridToolbarContainer to avoid CSS import
+ * issues in test environments while maintaining proper toolbar styling.
+ */
+export declare function TableToolbar({ buttons, testId, page, hasSelection, isEager, onDispatch, selectedRows, setFilterButtonEl, sortModel, filterModel, paginationModel, columns, showTotalCount, onAfterBulkDelete, confirm, }: TableToolbarProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=TableToolbar.d.ts.map

package/dist/renderers/TableToolbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TableToolbar.d.ts","sourceRoot":"","sources":["../../src/renderers/TableToolbar.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE3D,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEvF,OAAO,EACN,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,aAAa,EAElB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAOtD,MAAM,WAAW,iBAAiB;IACjC,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,YAAY,EAAE,OAAO,CAAC;IACtB,0EAA0E;IAC1E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,qFAAqF;IACrF,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9F,2DAA2D;IAC3D,YAAY,CAAC,EAAE,OAAO,EAAE,CAAC;IACzB,4EAA4E;IAC5E,iBAAiB,CAAC,EAAE,QAAQ,CAAC,cAAc,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC,CAAC;IACvE,uCAAuC;IACvC,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,yCAAyC;IACzC,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,6CAA6C;IAC7C,eAAe,CAAC,EAAE,mBAAmB,CAAC;IACtC,0CAA0C;IAC1C,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,wDAAwD;IACxD,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,wFAAwF;IACxF,iBAAiB,CAAC,EAAE,MAAM,IAAI,CAAC;IAC/B,6DAA6D;IAC7D,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC9D;AAGD,OAAO,QAAQ,kBAAkB,CAAC;IACjC,UAAU,qBAAsB,SAAQ,iBAAiB;KAAG;CAC5D;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,EAC5B,OAAO,EACP,MAAM,EACN,IAAI,EACJ,YAAY,EACZ,OAAO,EACP,UAAU,EACV,YAAY,EACZ,iBAAiB,EACjB,SAAS,EACT,WAAW,EACX,eAAe,EACf,OAAO,EACP,cAAc,EACd,iBAAiB,EACjB,OAAO,GACP,EAAE,iBAAiB,kDAkInB"}

package/dist/renderers/VisualElementRenderer.d.ts

@@ -0,0 +1,17 @@
+import { VisualElement } from '@judo/model-api';
+export interface VisualElementRendererProps {
+    element: VisualElement;
+    readOnly?: boolean;
+}
+/**
+ * Dispatcher for all visual element types.
+ * Checks for overrides in priority order:
+ * 1. sourceId-based override (CustomizationsConfig.components)
+ * 2. type-based interceptor (CustomizationsConfig.componentInterceptors)
+ * 3. Default rendering by @type
+ *
+ * When the element has a `subTheme` set and a matching provider is registered,
+ * the rendered output is wrapped in a scoped MUI ThemeProvider via SubThemeWrapper.
+ */
+export declare function VisualElementRenderer({ element, readOnly }: VisualElementRendererProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=VisualElementRenderer.d.ts.map

package/dist/renderers/VisualElementRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VisualElementRenderer.d.ts","sourceRoot":"","sources":["../../src/renderers/VisualElementRenderer.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EASX,aAAa,EACb,MAAM,iBAAiB,CAAC;AAWzB,MAAM,WAAW,0BAA0B;IAC1C,OAAO,EAAE,aAAa,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,0BAA0B,kDAqCtF"}

package/dist/utils/alignment-mappers.d.ts

@@ -0,0 +1,17 @@
+import { Alignment, CrossAxisAlignment, MainAxisAlignment } from '@judo/model-api';
+/**
+ * Map MainAxisAlignment enum to CSS justify-content value.
+ */
+export declare function mapMainAxisAlignment(alignment: MainAxisAlignment | undefined): string;
+/**
+ * Map CrossAxisAlignment enum to CSS align-items value.
+ */
+export declare function mapCrossAxisAlignment(alignment: CrossAxisAlignment | undefined): string;
+/**
+ * Map Alignment enum to CSS position properties.
+ */
+export declare function mapAlignment(alignment: Alignment | undefined): {
+    justifyContent: string;
+    alignItems: string;
+};
+//# sourceMappingURL=alignment-mappers.d.ts.map

package/dist/utils/alignment-mappers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alignment-mappers.d.ts","sourceRoot":"","sources":["../../src/utils/alignment-mappers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEnF;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,iBAAiB,GAAG,SAAS,GAAG,MAAM,CAiBrF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,kBAAkB,GAAG,SAAS,GAAG,MAAM,CAevF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,GAAG;IAC/D,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;CACnB,CAuBA"}

package/dist/utils/build-mask-string.d.ts

@@ -0,0 +1,31 @@
+import { AttributeType, RelationType } from '@judo/model-api';
+/**
+ * Build a JUDO mask string from attributes and relations.
+ *
+ * The mask format wraps comma-separated entries in curly braces.
+ * Plain attributes are listed by name, while relations include their
+ * target attributes in nested braces.
+ *
+ * @example
+ * // Attributes only
+ * buildMaskString({ attributes: [{ name: "born" }, { name: "name" }] })
+ * // => "{born,name}"
+ *
+ * @example
+ * // Attributes + relations
+ * buildMaskString({
+ *   attributes: [{ name: "born" }, { name: "name" }],
+ *   relations: [{ name: "messages", target: { attributes: [{ name: "message" }] } }],
+ * })
+ * // => "{born,name,messages{message}}"
+ *
+ * @example
+ * // Empty produces "{}"
+ * buildMaskString({ attributes: [] })
+ * // => "{}"
+ */
+export declare function buildMaskString(params: {
+    attributes?: AttributeType[];
+    relations?: RelationType[];
+}): string;
+//# sourceMappingURL=build-mask-string.d.ts.map

package/dist/utils/build-mask-string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-mask-string.d.ts","sourceRoot":"","sources":["../../src/utils/build-mask-string.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,UAAU,CAAC,EAAE,aAAa,EAAE,CAAC;IAAC,SAAS,CAAC,EAAE,YAAY,EAAE,CAAA;CAAE,GAAG,MAAM,CAyB5G"}

package/dist/utils/build-query-customizer.d.ts

@@ -0,0 +1,35 @@
+import { Column } from '@judo/model-api';
+import { GridFilterModel, GridPaginationModel, GridSortModel } from '@mui/x-data-grid';
+/**
+ * QueryCustomizer structure for REST API requests.
+ * Includes sorting, pagination, and filter criteria.
+ */
+export interface QueryCustomizer {
+    _orderBy?: {
+        attribute: string;
+        descending: boolean;
+    }[];
+    _seek?: {
+        limit: number;
+        offset: number;
+    };
+    [filterField: string]: unknown;
+}
+/**
+ * Parameters for building a QueryCustomizer from DataGrid state.
+ */
+export interface BuildQueryCustomizerParams {
+    sortModel: GridSortModel;
+    paginationModel: GridPaginationModel;
+    filterModel: GridFilterModel;
+    columns: Column[];
+}
+/**
+ * Build a QueryCustomizer object from DataGrid state (sort, pagination, filter).
+ * This is used for server-side table operations to include current state in API requests.
+ *
+ * @param params - The DataGrid state models and column definitions
+ * @returns QueryCustomizer object ready to be spread into an action
+ */
+export declare function buildQueryCustomizer(params: BuildQueryCustomizerParams): QueryCustomizer;
+//# sourceMappingURL=build-query-customizer.d.ts.map

package/dist/utils/build-query-customizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-query-customizer.d.ts","sourceRoot":"","sources":["../../src/utils/build-query-customizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAI5F;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,OAAO,CAAA;KAAE,EAAE,CAAC;IACxD,KAAK,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1C,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IAC1C,SAAS,EAAE,aAAa,CAAC;IACzB,eAAe,EAAE,mBAAmB,CAAC;IACrC,WAAW,EAAE,eAAe,CAAC;IAC7B,OAAO,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,0BAA0B,GAAG,eAAe,CAexF"}

package/dist/utils/destructive-action-utils.d.ts

@@ -0,0 +1,17 @@
+import { ConfirmDialogOptions } from '@judo/feedback';
+/**
+ * Set of action definition types that are considered destructive.
+ * These require user confirmation before execution.
+ */
+export declare const DESTRUCTIVE_ACTION_TYPES: Set<string>;
+/**
+ * Checks whether an action type is destructive (delete, remove, unset, clear).
+ * Handles both prefixed ("ui:DeleteActionDefinition") and unprefixed forms.
+ */
+export declare function isDestructiveAction(actionType?: string): boolean;
+/**
+ * Returns appropriate confirmation dialog options for a destructive action type.
+ * Handles both prefixed ("ui:DeleteActionDefinition") and unprefixed forms.
+ */
+export declare function getDestructiveConfirmationOptions(actionType: string): ConfirmDialogOptions;
+//# sourceMappingURL=destructive-action-utils.d.ts.map

package/dist/utils/destructive-action-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"destructive-action-utils.d.ts","sourceRoot":"","sources":["../../src/utils/destructive-action-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,wBAAwB,aAQnC,CAAC;AAEH;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAKhE;AAED;;;GAGG;AACH,wBAAgB,iCAAiC,CAAC,UAAU,EAAE,MAAM,GAAG,oBAAoB,CA8D1F"}

package/dist/utils/find-action-by-definition.d.ts

@@ -0,0 +1,26 @@
+import { Action, ActionDefinition, PageDefinition } from '@judo/model-api';
+/**
+ * Find an Action in page.actions that matches a given ActionDefinition by xmi:id.
+ *
+ * This is the core utility for matching visual element ActionDefinitions (inline/contained)
+ * with the corresponding Action entries in page.actions (which hold runtime metadata like
+ * targetPageDefinition, targetDataElement, etc.).
+ *
+ * @param page - The PageDefinition containing the actions array
+ * @param actionDefinition - The ActionDefinition to match (e.g., from a Button or container.onInit)
+ * @returns The matching Action, or undefined if no match is found
+ *
+ * @example
+ * ```typescript
+ * // For button click handling
+ * const action = findActionByDefinition(page, button.actionDefinition);
+ * if (action) {
+ *   dispatch(action);
+ * }
+ *
+ * // For onInit handling
+ * const onInitAction = findActionByDefinition(page, container.onInit);
+ * ```
+ */
+export declare function findActionByDefinition(page: PageDefinition, actionDefinition: ActionDefinition | undefined): Action | undefined;
+//# sourceMappingURL=find-action-by-definition.d.ts.map

package/dist/utils/find-action-by-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-action-by-definition.d.ts","sourceRoot":"","sources":["../../src/utils/find-action-by-definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEhF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,sBAAsB,CACrC,IAAI,EAAE,cAAc,EACpB,gBAAgB,EAAE,gBAAgB,GAAG,SAAS,GAC5C,MAAM,GAAG,SAAS,CAqBpB"}

package/dist/utils/find-on-init-action.d.ts

@@ -0,0 +1,12 @@
+import { Action, PageContainer, PageDefinition } from '@judo/model-api';
+/**
+ * Find the Action in page.actions that matches the container's onInit ActionDefinition.
+ * The onInit reference on PageContainer points to an ActionDefinition, and we need to
+ * find the corresponding Action in the page that uses that definition.
+ *
+ * @param page - The PageDefinition containing the actions array
+ * @param container - The PageContainer with an optional onInit reference
+ * @returns The matching Action, or undefined if no match is found
+ */
+export declare function findOnInitAction(page: PageDefinition, container: PageContainer): Action | undefined;
+//# sourceMappingURL=find-on-init-action.d.ts.map

package/dist/utils/find-on-init-action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-on-init-action.d.ts","sourceRoot":"","sources":["../../src/utils/find-on-init-action.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAG7E;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,EAAE,SAAS,EAAE,aAAa,GAAG,MAAM,GAAG,SAAS,CAEnG"}

package/dist/utils/find-visual-element.d.ts

@@ -0,0 +1,18 @@
+import { VisualElement } from '@judo/model-api';
+/**
+ * Find visual element by its @type property.
+ */
+export declare function findVisualElementByType<T extends VisualElement = VisualElement>(elements: VisualElement | VisualElement[], type: string): T | undefined;
+/**
+ * Find visual element by its xmi:id.
+ */
+export declare function findVisualElementById<T extends VisualElement = VisualElement>(elements: VisualElement | VisualElement[], id: string): T | undefined;
+/**
+ * Find visual element by its sourceId.
+ */
+export declare function findVisualElementBySourceId<T extends VisualElement = VisualElement>(elements: VisualElement | VisualElement[], sourceId: string): T | undefined;
+/**
+ * Flatten visual element tree to array.
+ */
+export declare function flattenVisualElements(elements: VisualElement | VisualElement[]): VisualElement[];
+//# sourceMappingURL=find-visual-element.d.ts.map

package/dist/utils/find-visual-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-visual-element.d.ts","sourceRoot":"","sources":["../../src/utils/find-visual-element.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhE;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa,EAC9E,QAAQ,EAAE,aAAa,GAAG,aAAa,EAAE,EACzC,IAAI,EAAE,MAAM,GACV,CAAC,GAAG,SAAS,CAiBf;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa,EAC5E,QAAQ,EAAE,aAAa,GAAG,aAAa,EAAE,EACzC,EAAE,EAAE,MAAM,GACR,CAAC,GAAG,SAAS,CAiBf;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa,EAClF,QAAQ,EAAE,aAAa,GAAG,aAAa,EAAE,EACzC,QAAQ,EAAE,MAAM,GACd,CAAC,GAAG,SAAS,CAiBf;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,aAAa,GAAG,aAAa,EAAE,GAAG,aAAa,EAAE,CAYhG"}

package/dist/utils/flex-layout.d.ts

@@ -0,0 +1,104 @@
+import { Axis } from '@judo/model-api';
+/** Default column span for visual elements (from EMF meta-model) */
+export declare const DEFAULT_COL = 4;
+/** Full grid width (12-column system) */
+export declare const FULL_GRID_WIDTH = 12;
+/**
+ * Grid size configuration for responsive breakpoints.
+ * - xs: extra small screens (mobile)
+ * - sm: small screens (tablets)
+ * - md: medium screens and above (desktop)
+ */
+export interface GridSize {
+    xs: number;
+    sm: number;
+    md?: number;
+}
+/**
+ * Calculate the scaled size for a child element based on parent's column span.
+ *
+ * **Legacy calculateSize logic:**
+ * - If parent spans full 12 columns: use child's col value as-is
+ * - If parent spans less than 12: scale proportionally (12 / parentCol) × childCol
+ *
+ * @param parentCol - Parent Flex container's column span (1-12)
+ * @param childCol - Child element's column span (1-12)
+ * @returns Calculated size (may exceed 12 if child is larger than parent)
+ *
+ * @example
+ * ```ts
+ * calculateScaledSize(12, 6); // 6  - parent full width, child uses col as-is
+ * calculateScaledSize(6, 3);  // 6  - (12/6) × 3 = 6
+ * calculateScaledSize(6, 6);  // 12 - (12/6) × 6 = 12 (full width)
+ * calculateScaledSize(4, 2);  // 6  - (12/4) × 2 = 6
+ * ```
+ */
+export declare function calculateScaledSize(parentCol: number, childCol: number): number;
+/**
+ * Calculate responsive grid size for horizontal flex layouts.
+ *
+ * **Responsive behavior:**
+ * - xs/sm breakpoints: always full width (12 columns) for mobile/tablet
+ * - md breakpoint: use calculated size for desktop
+ * - Optimization: omit md property if calculated size equals 12
+ *
+ * @param parentCol - Parent Flex container's column span
+ * @param childCol - Child element's column span
+ * @returns GridSize object with responsive breakpoint configuration
+ *
+ * @example
+ * ```ts
+ * calculateHorizontalGridSize(12, 6);  // { xs: 12, sm: 12, md: 6 }
+ * calculateHorizontalGridSize(6, 6);   // { xs: 12, sm: 12 } - omits md:12
+ * calculateHorizontalGridSize(8, 4);   // { xs: 12, sm: 12, md: 6 }
+ * ```
+ */
+export declare function calculateHorizontalGridSize(parentCol: number, childCol: number): GridSize;
+/**
+ * Calculate grid size for vertical flex layouts (Stack-based).
+ *
+ * **Vertical layout behavior:**
+ * - Always returns full width (12 columns) for all breakpoints
+ * - The `force-full-width` CSS class enforces 100% width on Stack children
+ * - No md breakpoint needed since width is always 100%
+ *
+ * @returns GridSize object with full width at all breakpoints
+ *
+ * @example
+ * ```ts
+ * calculateVerticalGridSize(); // { xs: 12, sm: 12 }
+ * ```
+ */
+export declare function calculateVerticalGridSize(): GridSize;
+/**
+ * Determine if a Flex container uses vertical layout direction.
+ *
+ * @param direction - Axis enum value from Flex element
+ * @returns true if vertical, false if horizontal
+ */
+export declare function isVerticalLayout(direction?: Axis): boolean;
+/**
+ * Calculate grid size for a child element based on parent's layout direction.
+ *
+ * **Decision logic:**
+ * - Vertical layouts: always full width (Stack + force-full-width CSS)
+ * - Horizontal layouts: responsive sizing with calculated md breakpoint
+ *
+ * @param direction - Parent Flex container's direction
+ * @param parentCol - Parent Flex container's column span
+ * @param childCol - Child element's column span
+ * @returns GridSize object with appropriate responsive configuration
+ *
+ * @example
+ * ```ts
+ * // Vertical layout - always full width
+ * calculateChildGridSize('VERTICAL', 12, 6);    // { xs: 12, sm: 12 }
+ * calculateChildGridSize('VERTICAL', 6, 3);     // { xs: 12, sm: 12 }
+ *
+ * // Horizontal layout - responsive sizing
+ * calculateChildGridSize('HORIZONTAL', 12, 6);  // { xs: 12, sm: 12, md: 6 }
+ * calculateChildGridSize('HORIZONTAL', 6, 3);   // { xs: 12, sm: 12, md: 6 }
+ * ```
+ */
+export declare function calculateChildGridSize(direction: Axis | undefined, parentCol: number, childCol: number): GridSize;
+//# sourceMappingURL=flex-layout.d.ts.map

package/dist/utils/flex-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flex-layout.d.ts","sourceRoot":"","sources":["../../src/utils/flex-layout.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC,oEAAoE;AACpE,eAAO,MAAM,WAAW,IAAI,CAAC;AAE7B,yCAAyC;AACzC,eAAO,MAAM,eAAe,KAAK,CAAC;AAElC;;;;;GAKG;AACH,MAAM,WAAW,QAAQ;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,CAAC,EAAE,MAAM,CAAC;CACZ;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAK/E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAazF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,IAAI,QAAQ,CAEpD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,CAAC,EAAE,IAAI,GAAG,OAAO,CAE1D;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,IAAI,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAKjH"}

package/dist/utils/get-visible-buttons.d.ts

@@ -0,0 +1,33 @@
+import { Action, Button } from '@judo/model-api';
+/**
+ * Options for filtering visible buttons.
+ */
+export interface GetVisibleButtonsOptions {
+    /** Whether the page is currently in edit mode (has unsaved changes) */
+    isEditMode?: boolean;
+}
+/**
+ * Filter buttons to only show those with matching page actions.
+ * A button is visible if there's a page Action whose actionDefinition
+ * references the same ActionDefinition as the button.
+ *
+ * Additional visibility rules:
+ * - UpdateActionDefinition (Save) and CancelActionDefinition (Cancel) buttons
+ *   are only visible when isEditMode=true.
+ *
+ * @param buttons - Array of buttons to filter
+ * @param pageActions - Optional array of page actions to match against
+ * @param options - Optional visibility options
+ * @returns Filtered array of buttons that have matching page actions
+ *
+ * @example
+ * ```typescript
+ * const visibleButtons = getVisibleButtons(
+ *   buttonGroup.buttons,
+ *   page.actions,
+ *   { isEditMode: true }
+ * );
+ * ```
+ */
+export declare function getVisibleButtons(buttons: Button[], pageActions?: Action[], options?: GetVisibleButtonsOptions): Button[];
+//# sourceMappingURL=get-visible-buttons.d.ts.map

package/dist/utils/get-visible-buttons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-visible-buttons.d.ts","sourceRoot":"","sources":["../../src/utils/get-visible-buttons.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAQtD;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACxC,uEAAuE;IACvE,UAAU,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,MAAM,EAAE,EACjB,WAAW,CAAC,EAAE,MAAM,EAAE,EACtB,OAAO,GAAE,wBAA6B,GACpC,MAAM,EAAE,CA+CV"}

package/dist/utils/icon-adornment.d.ts

@@ -0,0 +1,13 @@
+import { Icon } from '@judo/model-api';
+/**
+ * Build a MUI `startAdornment` for a TextField-based input if the model element
+ * has an icon defined. Returns `undefined` when no icon is present so that callers
+ * can spread the result into slotProps without conditional logic.
+ *
+ * @example
+ * ```tsx
+ * <TextField slotProps={{ input: { startAdornment: buildIconAdornment(element.icon) } }} />
+ * ```
+ */
+export declare function buildIconAdornment(icon: Icon | undefined): React.ReactNode | undefined;
+//# sourceMappingURL=icon-adornment.d.ts.map

package/dist/utils/icon-adornment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"icon-adornment.d.ts","sourceRoot":"","sources":["../../src/utils/icon-adornment.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAI5C;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,GAAG,KAAK,CAAC,SAAS,GAAG,SAAS,CAQtF"}

package/dist/utils/mdi-alias-map.d.ts

@@ -0,0 +1,44 @@
+/**
+ * MDI Icon Alias Resolution
+ *
+ * Uses a pre-generated alias map for efficient alias resolution.
+ * The map is generated from @mdi/svg metadata at build time.
+ *
+ * The webfont CSS only contains classes for canonical names (e.g., `mdi-note-plus`),
+ * not aliases (e.g., `note-add`). This module resolves aliases at runtime.
+ *
+ * Also normalizes underscores to hyphens (e.g., `delete_forever` -> `delete-forever`)
+ * since MDI uses hyphens but some models may use underscores.
+ *
+ * To regenerate the alias map after updating @mdi/svg:
+ *   pnpm generate:icons
+ */
+/**
+ * Resolves an icon name to its canonical MDI name.
+ *
+ * 1. Normalizes underscores to hyphens (e.g., `delete_forever` -> `delete-forever`)
+ * 2. If the result is an alias, returns the canonical name
+ * 3. Otherwise returns the normalized name unchanged
+ *
+ * @example
+ * resolveIconName('note-add')       // returns 'note-plus' (alias resolved)
+ * resolveIconName('note_add')       // returns 'note-plus' (normalized + alias resolved)
+ * resolveIconName('delete_forever') // returns 'delete-forever' (normalized)
+ * resolveIconName('home')           // returns 'home' (already canonical)
+ * resolveIconName('unknown-icon')   // returns 'unknown-icon' (passthrough)
+ */
+export declare function resolveIconName(name: string): string;
+/**
+ * Checks if a name is an alias (not a canonical icon name).
+ * Normalizes underscores to hyphens before checking.
+ */
+export declare function isAlias(name: string): boolean;
+/**
+ * Gets all aliases for a canonical icon name.
+ * Returns empty array if no aliases exist.
+ *
+ * Note: This requires iterating the map. For frequent lookups,
+ * consider caching the result.
+ */
+export declare function getAliases(canonicalName: string): string[];
+//# sourceMappingURL=mdi-alias-map.d.ts.map

package/dist/utils/mdi-alias-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdi-alias-map.d.ts","sourceRoot":"","sources":["../../src/utils/mdi-alias-map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAYH;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGpD;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7C;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ1D"}

package/dist/utils/mdi-alias-map.generated.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Generated MDI alias map - DO NOT EDIT
+ *
+ * Generated from @mdi/svg metadata
+ * Icons: 7447, Aliases: 6476
+ *
+ * Run: pnpm generate:icons to regenerate
+ */
+export declare const MDI_ALIAS_MAP: Record<string, string>;
+//# sourceMappingURL=mdi-alias-map.generated.d.ts.map

package/dist/utils/mdi-alias-map.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdi-alias-map.generated.d.ts","sourceRoot":"","sources":["../../src/utils/mdi-alias-map.generated.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA60MhD,CAAC"}

package/dist/utils/resolve-container-type.d.ts

@@ -0,0 +1,11 @@
+import { PageContainer, PageContainerType } from '@judo/model-api';
+/**
+ * Resolve the effective container type.
+ * In EMF/ECore, default enum values are not serialized.
+ * Since TABLE is the first literal (value 0), it's the default when type is not present.
+ *
+ * Separated from PageRenderer.tsx to preserve HMR boundaries.
+ * See: specs/HMR.md — Standard I: Single-Authority Export Mandate
+ */
+export declare function resolveContainerType(container: PageContainer): PageContainerType;
+//# sourceMappingURL=resolve-container-type.d.ts.map

package/dist/utils/resolve-container-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-container-type.d.ts","sourceRoot":"","sources":["../../src/utils/resolve-container-type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEpD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,aAAa,GAAG,iBAAiB,CAOhF"}

package/dist/utils/singleton-access.d.ts

@@ -0,0 +1,25 @@
+import { PageDefinition, RelationType } from '@judo/model-api';
+/**
+ * Check if a page is a singleton access page.
+ *
+ * A singleton access page is an AccessViewPage whose dataElement is a RelationType with:
+ * - isAccess = true (it's an access relation, i.e., top-level entry point)
+ * - isCollection = false (there's exactly one instance, not a list)
+ *
+ * Singleton access pages don't require a signedIdentifier in the URL because
+ * there's only one transfer behind the relation. The transfer's signedIdentifier
+ * must be resolved at runtime by calling refreshAccessRelation before the
+ * normal onInit refresh can proceed.
+ *
+ * @param page - The PageDefinition to check
+ * @returns true if the page is a singleton access page
+ */
+export declare function isSingletonAccessPage(page: PageDefinition): boolean;
+/**
+ * Get the access relation from a singleton access page.
+ *
+ * @param page - The PageDefinition (must be a singleton access page)
+ * @returns The RelationType representing the access relation, or undefined
+ */
+export declare function getSingletonAccessRelation(page: PageDefinition): RelationType | undefined;
+//# sourceMappingURL=singleton-access.d.ts.map

package/dist/utils/singleton-access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleton-access.d.ts","sourceRoot":"","sources":["../../src/utils/singleton-access.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAenE;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,cAAc,GAAG,YAAY,GAAG,SAAS,CAKzF"}

package/dist/utils/table-column-utils.d.ts

@@ -0,0 +1,75 @@
+import { Button as ButtonElement, Column } from '@judo/model-api';
+import { GridColType } from '@mui/x-data-grid';
+/**
+ * Row action types that are automatically shown inline (featured) when
+ * `featuredActions` is 0 (i.e., no explicit featured actions configured).
+ *
+ * Includes navigation and CRUD operations that benefit from direct visibility:
+ * - OpenPageActionDefinition: View/navigate to row detail page
+ * - RowOpenPageActionDefinition: Row-level view navigation
+ * - RowDeleteActionDefinition: Delete the row (requires `__deleteable` runtime check)
+ * - RemoveActionDefinition: Remove from relation
+ * - OpenSetSelectorActionDefinition: Set a relation target
+ * - UnsetActionDefinition: Unset a relation target
+ */
+export declare const AUTO_FEATURED_ROW_ACTION_TYPES: Set<string>;
+/**
+ * Maps model data types to MUI DataGrid column types.
+ *
+ * MUI DataGrid column types:
+ * - 'string' (default): Text values
+ * - 'number': Numeric values with number formatting
+ * - 'date': Date values (rendered with date picker)
+ * - 'dateTime': DateTime/Timestamp values
+ * - 'boolean': Boolean values (rendered with checkbox)
+ * - 'singleSelect': Enumeration values (dropdown)
+ * - 'actions': Action column (special)
+ *
+ * @param column The model Column definition
+ * @returns The MUI DataGrid column type
+ */
+export declare function getColumnType(column: Column): GridColType;
+/**
+ * Gets value options for enumeration columns.
+ * @param column The model Column definition
+ * @returns Array of value options for singleSelect type, or undefined
+ */
+export declare function getEnumerationValueOptions(column: Column): Array<{
+    value: string;
+    label: string;
+}> | undefined;
+/**
+ * Determines if a table column is sortable.
+ * A column is sortable if:
+ * 1. It has an attributeType
+ * 2. The attributeType's dataType is NOT BinaryType
+ * 3. The attributeType's memberType is NOT TRANSIENT
+ */
+export declare function isColumnSortable(column: Column): boolean;
+/**
+ * Calculates the width needed for an action column based on button content.
+ *
+ * When `featuredActions` is provided, the calculation accounts for the
+ * featured/overflow split pattern (inline buttons + dropdown trigger):
+ * - featuredActions = 0: auto-CRUD mode — CRUD buttons shown inline, rest in dropdown.
+ *   Width accounts for all CRUD buttons (worst-case, including delete).
+ * - featuredActions > 0: featured button widths + dropdown trigger (if overflow)
+ * - featuredActions >= total: all buttons inline, no dropdown (same as legacy)
+ *
+ * When `featuredActions` is not provided, all buttons are treated as inline
+ * (backward compatible with legacy behavior).
+ *
+ * Calculation uses actual MUI small outlined Button metrics:
+ * - Text width: ~6.5px per character (13px font-size, proportional sans-serif)
+ * - Icon width: 24px (18px icon + 8px margin - 2px offset)
+ * - Button padding: 18px (9px left + 9px right for small outlined)
+ * - Dropdown trigger: 36px (18px padding + 18px icon)
+ * - Spacing: 0px (ButtonGroup collapses borders)
+ * - Column padding: 20px (DataGrid cell padding ~10px per side)
+ *
+ * @param buttons Array of buttons to display in the action column
+ * @param featuredActions Number of featured actions to show inline (from ButtonGroup model)
+ * @returns Calculated width in pixels
+ */
+export declare function calculateActionColumnWidth(buttons: ButtonElement[], featuredActions?: number): number;
+//# sourceMappingURL=table-column-utils.d.ts.map

package/dist/utils/table-column-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-column-utils.d.ts","sourceRoot":"","sources":["../../src/utils/table-column-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,8BAA8B,aAOzC,CAAC;AAEH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAkCzD;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,SAAS,CAoB9G;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAkBxD;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,aAAa,EAAE,EAAE,eAAe,CAAC,EAAE,MAAM,GAAG,MAAM,CAkErG"}

package/dist/utils/table-filter-utils.d.ts

@@ -0,0 +1,14 @@
+import { Column } from '@judo/model-api';
+import { GridFilterModel } from '@mui/x-data-grid';
+/**
+ * Convert MUI GridFilterModel to QueryCustomizer filter format.
+ *
+ * MUI format: { items: [{ field: "name", operator: "contains", value: "John" }] }
+ * JUDO format: { "name": [{ operator: "like", value: "%John%" }] }
+ *
+ * @param model - MUI DataGrid filter model
+ * @param columns - Table columns for type information (optional)
+ * @returns QueryCustomizer-compatible filter object
+ */
+export declare function convertFilterModelToQueryCustomizer(model: GridFilterModel, columns?: Column[]): Record<string, any> | undefined;
+//# sourceMappingURL=table-filter-utils.d.ts.map