impact-nova 2.0.9 → 2.1.0-alpha.1

package/README.md

@@ -47,12 +47,35 @@ Visit **[https://impact-nova.iaproducts.ai/](https://impact-nova.iaproducts.ai/)
 
 That documentation site is published with **Storybook** ([storybook.js.org](https://storybook.js.org/)), the same format many design systems use; you can treat the URL like any other docs hub even if you are not familiar with Storybook.
 
+**Repo guides:** [Getting started](./docs/guides/getting-started.md) · [Deprecations](./docs/guides/deprecations.md) · [Testing](./docs/guides/testing.md) · [All guides](./docs/guides/README.md)
+
 ### MCP server (`impact-nova-mcp`)
 
 Use **[impact-nova-mcp on npm](https://www.npmjs.com/package/impact-nova-mcp)** if you want a **Model Context Protocol** (MCP) server for Impact Nova in **Cursor**, **Windsurf**, **Claude**, **Antigravity**, or other MCP-capable clients—component lists, specs, design tokens, codegen, and conventions wired for assistants.
 
 What MCP is, what this server exposes, and how to install and configure your editor are documented in **[packages/mcp/README.md](packages/mcp/README.md)** in this repository.
 
+### Ecosystem tooling (MCP, doctor, ESLint, codemods)
+
+| Tool | npm? | Use in app repos |
+|------|------|------------------|
+| **impact-nova-mcp** | ✅ Published | MCP tools for agents (`get_component`, `validate_usage`, …) |
+| **impact-nova-doctor** | ✅ Bin on `impact-nova-mcp` | `npx impact-nova-doctor` — CI compliance scan |
+| **create-impact-nova** | ✅ Published | `npx create-impact-nova` — Vite + Nova scaffold |
+| **eslint-plugin-impact-nova** | ❌ Monorepo only (for now) | Charter ESLint rules — used inside this repo, not on npm yet |
+| **@impact-nova/codemods** | ❌ Monorepo only (for now) | Prop migration transforms — maintainer tooling until published |
+
+Full matrix: **[docs/guides/consumer-tooling.md](docs/guides/consumer-tooling.md)**.
+
+```bash
+# Typical consumer app setup
+npm install impact-nova impact-nova-icons
+npm install -D impact-nova-mcp
+npx impact-nova-doctor
+```
+
+Scaffolds from `create-impact-nova` include `doctor` scripts and a GitHub Actions workflow for PR validation.
+
 ### LLM editor rules (`impact-nova/llms` + vibe-rules)
 
 This package ships a **`./llms`** export so assistants can load **static** Impact Nova conventions from the same Markdown as **impact-nova-mcp** under [`packages/mcp/data/`](packages/mcp/data). It is built into **`dist/llms`** when you run `npm run build` on this repo.
@@ -131,21 +154,27 @@ Impact Nova looks best with **Manrope**. We recommend adding it to your project:
 
 ## 🔨 Usage
 
-Import components directly from the package. All components export strong TypeScript definitions for props and events.
+Import components via **subpath exports** for tree-shaking. All components export strong TypeScript definitions.
+
+> Prefer subpath imports in application code. The root barrel (`impact-nova`) exists for convenience only.
 
 ### Core Components
 
 ```tsx
-import { Button, Card, DatePicker } from "impact-nova";
+import { Button } from "impact-nova/button";
+import { Card, CardContent, CardHeader, CardTitle } from "impact-nova/card";
+import { DatePicker } from "impact-nova/date-picker";
 
-export default function MyPage() {
+export function MyPage() {
   return (
     <Card className="p-6">
-      <h1 className="text-xl font-bold mb-4">Dashboard</h1>
-      <div className="flex gap-4">
+      <CardHeader>
+        <CardTitle>Dashboard</CardTitle>
+      </CardHeader>
+      <CardContent className="flex gap-4">
         <DatePicker />
-        <Button variant="primary">Save Changes</Button>
-      </div>
+        <Button variant="default">Save Changes</Button>
+      </CardContent>
     </Card>
   );
 }
@@ -153,15 +182,15 @@ export default function MyPage() {
 
 ### Using Icons
 
-Impact Nova includes a custom-built icon library. Icons are treeshakeable and accept standard SVG props.
+Icons ship in the peer package **`impact-nova-icons`**. Import named icons directly:
 
 ```tsx
-import { Icons } from "impact-nova";
+import { CheckCircle } from "impact-nova-icons";
 
 export function StatusBadge() {
   return (
     <div className="flex items-center gap-2 text-green-600">
-      <Icons.CheckCircle size={16} />
+      <CheckCircle size={16} />
       <span>Operation Successful</span>
     </div>
   );
@@ -170,10 +199,10 @@ export function StatusBadge() {
 
 ### Type Safety
 
-You can import component props to ensure type safety in your own interfaces.
+Import props from the same subpath as the component:
 
 ```tsx
-import { Button, type ButtonProps } from "impact-nova";
+import { Button, type ButtonProps } from "impact-nova/button";
 
 interface CustomActionProps extends ButtonProps {
   analyticsId: string;
@@ -235,17 +264,18 @@ Calendar, date pickers, Select, NestedList, DataTableColumnList, and aria labels
 
 ---
 
-## 🏗️ Architecture
+## Architecture
 
-The library utilizes a modern, headless architecture pattern:
+The library uses a **category-folder** source layout (`primitives/`, `forms/`, `data/`, `flows/`, …) with stable **subpath exports** for consumers. See [component-layout.md](docs/guides/component-layout.md).
 
-1.  **Logic Layer**: Headless state management and interactions powered by Radix UI and internal hooks.
-2.  **Styling Layer**: Utility-first CSS using **Tailwind CSS** and **class-variance-authority (CVA)** for scalable, type-safe component variant management.
-3.  **Build System**: High-performance tooling with Vite and React 19 for instant HMR.
+1. **Logic Layer**: Headless state management and interactions powered by Radix UI and internal hooks.
+2. **Styling Layer**: Utility-first CSS using **Tailwind CSS** and **class-variance-authority (CVA)** for scalable, type-safe component variant management.
+3. **Build System**: High-performance tooling with Vite and React 19 for instant HMR.
+4. **Registry + MCP**: Component metadata is generated from TypeScript for AI tools (`impact-nova-mcp`).
 
 ---
 
-## � Component Library
+## Component Library
 
 Impact Nova provides a rich set of components structured for any enterprise use-case.
 

package/dist/components/data/ag-grid-react/ag-grid-cell-components.d.ts

@@ -0,0 +1,65 @@
+export declare const AG_GRID_CELL_COMPONENTS: {
+    readonly empty: {
+        (): null;
+        displayName: string;
+    };
+    readonly badge: {
+        (props: import('./cell-renderers/badge-cell-renderer').BadgeCellRendererProps): import("react/jsx-runtime").JSX.Element | null;
+        displayName: string;
+    };
+    readonly statusBadge: {
+        (props: import('./cell-renderers/status-badge-renderer').StatusBadgeRendererProps): import("react/jsx-runtime").JSX.Element | null;
+        displayName: string;
+    };
+    readonly actions: {
+        (props: import('./cell-renderers/actions-cell-renderer').ActionsCellRendererProps): import("react/jsx-runtime").JSX.Element | null;
+        displayName: string;
+    };
+    readonly link: {
+        (props: import('./cell-renderers/link-with-batch-cell-renderer').LinkCellRendererProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    readonly split: {
+        (props: import('./cell-renderers/split-cell-renderer').SplitCellRendererProps): import("react/jsx-runtime").JSX.Element | null;
+        displayName: string;
+    };
+    readonly inputDisplay: {
+        (props: import('./cell-renderers/input-display-renderer').InputDisplayRendererProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    readonly selectDisplay: {
+        (props: import('./cell-renderers/select-display-renderer').SelectDisplayRendererProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    readonly checkboxDisplay: {
+        (props: import('./cell-renderers/checkbox-display-renderer').CheckboxDisplayRendererProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    readonly switchDisplay: {
+        (props: import('./cell-renderers/switch-display-renderer').SwitchDisplayRendererProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    readonly textareaDisplay: {
+        (props: import('./cell-renderers/textarea-display-renderer').TextAreaDisplayRendererProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    readonly dateDisplay: {
+        (props: import('./cell-renderers/date-display-renderer').DateDisplayRendererProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    readonly percentProgressDisplay: {
+        (props: import('./cell-renderers/percent-progress-display-renderer').PercentProgressDisplayRendererProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    readonly inputEditor: import('react').NamedExoticComponent<import('./cell-renderers/editors/input-cell-editor').InputCellEditorProps & import('react').RefAttributes<import('./cell-renderers/editors/input-cell-editor').InputCellEditorHandle>>;
+    readonly selectEditor: import('react').ForwardRefExoticComponent<import('./cell-renderers/editors/select-cell-editor').SelectCellEditorProps & import('react').RefAttributes<unknown>>;
+    readonly textareaEditor: import('react').ForwardRefExoticComponent<import('./cell-renderers/editors/textarea-cell-editor').TextAreaCellEditorProps & import('react').RefAttributes<unknown>>;
+    readonly dateEditor: import('react').ForwardRefExoticComponent<import('./cell-renderers/editors/date-cell-editor').DateCellEditorProps & import('react').RefAttributes<unknown>>;
+    readonly splitEditor: import('react').ForwardRefExoticComponent<import('./cell-renderers/editors/split-cell-editor').SplitCellEditorProps & import('react').RefAttributes<unknown>>;
+    readonly percentProgressEditor: import('react').NamedExoticComponent<import('./cell-renderers/editors/percent-progress-cell-editor').PercentProgressCellEditorProps & import('react').RefAttributes<{
+        getValue: () => unknown;
+        isCancelBeforeStart: () => boolean;
+        isCancelAfterEnd: () => boolean;
+    }>>;
+};
+export type AgGridCellComponentKey = keyof typeof AG_GRID_CELL_COMPONENTS;

package/dist/components/data/ag-grid-react/ag-grid-react.types.d.ts

@@ -0,0 +1 @@
+export type { AgGridWrapperProps, ImpactNovaColDef, ExtendedHeaderComponentParams, AdvancedFilterModel, } from './ag-grid.types';

package/dist/components/data/ag-grid-react/ag-grid.types.d.ts

@@ -0,0 +1,193 @@
+import { ReactNode } from 'react';
+import { ColDef, ColGroupDef, IHeaderParams, IHeaderGroupParams, Column, ValueFormatterParams } from 'ag-grid-community';
+import { AgGridReactProps } from 'ag-grid-react';
+/** ColDef extended with Impact Nova runtime metadata set during column processing */
+export interface ImpactNovaColDef<TData = unknown> extends ColDef<TData> {
+    /** Original column-level editable before addRowDataEditableCheck wraps the callback */
+    _originalEditable?: boolean;
+}
+/**
+ * Extended header component params for custom header
+ * Extends IHeaderParams to include all AG Grid header properties plus custom ones
+ */
+export interface ExtendedHeaderComponentParams extends Partial<IHeaderParams> {
+    /** Whether to show the info icon */
+    showInfoIcon?: boolean;
+    /** Tooltip text for the info icon */
+    infoTooltip?: string;
+    /** Callback when info icon is clicked */
+    onInfoClick?: (params: IHeaderParams | IHeaderGroupParams) => void;
+    handleInlineSearch?: (value: string | number | Date | null) => void;
+    handleClearSearchInline?: (params: IHeaderParams) => void;
+    handleCloseInputField?: () => void;
+    onColumnSearchClick?: (params: IHeaderParams) => void;
+    onAdvanceSearchClick?: (column: Column) => void;
+    toggleAdvanceSearch?: (colId: string) => void;
+    isSearchable?: boolean;
+    advanceSearchEnabled?: boolean;
+    selectOptions?: Array<{
+        label: string | ReactNode;
+        value: string;
+        [key: string]: unknown;
+    }>;
+    isMultiSelect?: boolean;
+    onSelectScrollToBottom?: () => void;
+    onSelectSearchChange?: (value: string) => void;
+    onSelectOpen?: () => void;
+    isLoadingSelect?: boolean;
+    fetchSelectError?: Error | null;
+    enableSpaceSplitting?: boolean;
+    enableBooleanParsing?: boolean;
+    enableDateParsing?: boolean;
+    /** Which picker to render for date columns. Default: 'date' */
+    datePickerVariant?: 'date' | 'month' | 'week';
+    /** Display format for dates in this column (date-fns token string). Default: "MM/dd/yyyy" */
+    dateDisplayFormat?: string;
+    /** Fiscal calendar configuration for week/month picker */
+    fiscalConfig?: {
+        calendarType?: 'calendar' | 'fiscal';
+        fiscalMode?: 'basic' | 'advanced' | 'custom';
+        selectionMode?: 'week' | 'fiscalMonth';
+        fiscalMonthPattern?: number[];
+        fiscalYearStartMonth?: number;
+        weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    };
+    /** Generic info data for the info modal */
+    infoData?: InfoContent;
+    /** How to display the information (tooltip or modal) */
+    displayMode?: 'tooltip' | 'modal';
+}
+export type SectionType = 'TEXT' | 'KEY_VALUE' | 'BADGES' | 'LINK';
+export interface UISectionBase {
+    type: SectionType;
+    /** Whether to show a separator above or below this section */
+    separator?: boolean | 'top' | 'bottom' | 'both';
+}
+export interface TextSection extends UISectionBase {
+    type: 'TEXT';
+    variant?: 'heading' | 'paragraph' | 'caption';
+    data: {
+        label?: string;
+        content: string;
+    };
+}
+export interface KeyValueItem {
+    label: string;
+    value: string | number | boolean;
+}
+export interface KeyValueSection extends UISectionBase {
+    type: 'KEY_VALUE';
+    data: {
+        items: KeyValueItem[];
+    };
+}
+export interface BadgesSection extends UISectionBase {
+    type: 'BADGES';
+    data: {
+        label?: string;
+        items: {
+            label: string;
+            variant?: 'solid' | 'outline' | 'subtle';
+            color?: 'primary' | 'success' | 'warning' | 'destructive';
+        }[];
+    };
+}
+export interface LinkSection extends UISectionBase {
+    type: 'LINK';
+    data: {
+        label?: string;
+        text: string;
+        url: string;
+    };
+}
+export type UISection = TextSection | KeyValueSection | BadgesSection | LinkSection;
+export interface InfoContent {
+    title?: string;
+    description?: string;
+    sections: UISection[];
+}
+/**
+ * Props for the AgGridWrapper component
+ */
+export interface AgGridWrapperProps<TData = unknown> extends Omit<AgGridReactProps<TData>, 'theme' | 'defaultColDef' | 'defaultColGroupDef'> {
+    /**
+     * Children to render inside the grid container
+     */
+    children?: ReactNode;
+    /**
+     * Default column definition (will be merged with wrapper defaults)
+     */
+    defaultColDef?: ColDef<TData>;
+    /**
+     * Default column group definition (will be merged with wrapper defaults)
+     */
+    defaultColGroupDef?: ColGroupDef<TData>;
+    /**
+     * When true (default), DOM order matches visual order for screen readers.
+     * Large planning grids should pass false for better column virtualization.
+     */
+    ensureDomOrder?: boolean;
+    /**
+     * Value formatter registry - maps formatter names to formatter functions
+     * Allows backend to specify formatters by string name (e.g., "currency", "percentage")
+     *
+     * @example
+     * ```typescript
+     * valueFormatters={{
+     *   currency: (params) => `$${params.value.toFixed(2)}`,
+     *   percentage: (params) => `${params.value}%`,
+     * }}
+     *
+     * // Backend can then send:
+     * { field: 'price', valueFormatter: 'currency' }
+     * ```
+     */
+    valueFormatters?: Record<string, (params: ValueFormatterParams) => string>;
+}
+/**
+ * Filter operators for advanced filtering.
+ * Supports text, numeric, and special operators.
+ */
+export type FilterOperator = 'contains' | 'notContains' | 'equals' | 'notEqual' | 'startsWith' | 'endsWith' | 'greaterThan' | 'greaterThanOrEqual' | 'lessThan' | 'lessThanOrEqual' | 'inRange' | 'empty' | 'notEmpty';
+/**
+ * A single filter rule targeting one column.
+ */
+export interface AdvancedFilterRule {
+    /** Unique identifier for the rule */
+    id: string;
+    /** The column ID to filter */
+    columnId: string;
+    /** The filter operator */
+    operator: FilterOperator;
+    /** The primary filter value */
+    value: string | string[];
+    /** Secondary value for range filters (inRange) */
+    valueTo?: string;
+    /** Column type for proper AG Grid filterType (derived from colDef.filter) */
+    columnType?: 'text' | 'number' | 'date' | 'select' | 'multi';
+}
+/**
+ * A group of filter conditions with AND/OR logic.
+ * Can contain rules or nested groups.
+ */
+export interface AdvancedFilterGroup {
+    /** Unique identifier for the group */
+    id: string;
+    /** Logical operator to combine conditions */
+    logic: 'AND' | 'OR';
+    /** Child conditions (rules or nested groups) */
+    conditions: (AdvancedFilterRule | AdvancedFilterGroup)[];
+}
+/**
+ * The complete advanced filter model.
+ * Contains top-level logic and array of rules/groups.
+ */
+export interface AdvancedFilterModel {
+    /** Top-level logical operator (fallback when columnLogic is missing for a column) */
+    logic: 'AND' | 'OR';
+    /** Array of filter rules or groups */
+    rules: (AdvancedFilterRule | AdvancedFilterGroup)[];
+    /** Per-column logic operators. Key = columnId, value = AND/OR.
+     *  When present, takes precedence over the top-level `logic` for that column. */
+    columnLogic?: Record<string, 'AND' | 'OR'>;
+}

package/dist/components/data/ag-grid-react/cell-renderers/actions-cell-renderer.d.ts

@@ -0,0 +1,30 @@
+import { ICellRendererParams } from 'ag-grid-community';
+import { ActionButton } from './types';
+export interface ActionsCellRendererProps extends ICellRendererParams {
+    /** Array of action button configurations */
+    actions: ActionButton[];
+}
+/**
+ * ActionsCellRenderer - Display-only renderer showing action buttons.
+ *
+ * Stateless: renders buttons from the `actions` array config.
+ * Each button's onClick receives the row data.
+ *
+ * Usage in colDef:
+ * ```ts
+ * {
+ *   headerName: 'Actions',
+ *   cellRenderer: ActionsCellRenderer,
+ *   cellRendererParams: {
+ *     actions: [
+ *       { label: 'Edit', onClick: (data) => editRow(data), variant: 'outline', size: 'sm' },
+ *       { label: 'Delete', onClick: (data) => deleteRow(data), variant: 'destructive', size: 'sm' },
+ *     ]
+ *   }
+ * }
+ * ```
+ */
+export declare const ActionsCellRenderer: {
+    (props: ActionsCellRendererProps): import("react/jsx-runtime").JSX.Element | null;
+    displayName: string;
+};

package/dist/components/data/ag-grid-react/cell-renderers/actions-cell-renderer.js

@@ -0,0 +1,27 @@
+import { jsx as r, jsxs as s, Fragment as n } from "react/jsx-runtime";
+import { Button as m } from "../../../primitives/button/button.js";
+const t = (i) => {
+  const { actions: l, data: a } = i;
+  return !l || l.length === 0 ? null : /* @__PURE__ */ r("div", { className: "flex gap-2 items-center h-full w-full ag-cell-inner-padding", children: l.map((e, d) => /* @__PURE__ */ r(
+    m,
+    {
+      onClick: () => e.onClick(a),
+      variant: e.variant ?? "default",
+      size: e.size ?? "sm",
+      className: e.className,
+      disabled: e.disabled,
+      children: e.iconPlacement === "right" ? /* @__PURE__ */ s(n, { children: [
+        e.label,
+        e.icon
+      ] }) : /* @__PURE__ */ s(n, { children: [
+        e.icon,
+        e.label
+      ] })
+    },
+    d
+  )) });
+};
+t.displayName = "ActionsCellRenderer";
+export {
+  t as ActionsCellRenderer
+};

package/dist/components/data/ag-grid-react/cell-renderers/badge-cell-renderer.d.ts

@@ -0,0 +1,44 @@
+import { ICellRendererParams } from 'ag-grid-community';
+export interface BadgeCellRendererProps extends ICellRendererParams {
+    /** Badge variant: 'filled' | 'stroke' | 'subtle' (mapped to impact-nova variants) */
+    variant?: string;
+    variantField?: string;
+    /** Badge color: 'default' | 'info' | 'success' | 'warning' | 'error' (mapped to impact-nova colors) */
+    color?: string;
+    colorField?: string;
+    /** Whether to show an icon inside the badge */
+    isIcon?: boolean;
+    isIconField?: string;
+    /** Icon element to display inside the badge */
+    icon?: React.ReactNode;
+    iconField?: string;
+    /** Badge label (overrides cell value) */
+    badgeLabel?: string;
+    badgeLabelField?: string;
+    /** Badge size */
+    size?: 'small' | 'default';
+    sizeField?: string;
+}
+/**
+ * BadgeCellRenderer - Display-only renderer showing a Badge component.
+ *
+ * Stateless: derives everything from props and row data.
+ * Supports both static props and dynamic field-driven values.
+ *
+ * Usage in colDef:
+ * ```ts
+ * {
+ *   field: 'status',
+ *   cellRenderer: BadgeCellRenderer,
+ *   cellRendererParams: {
+ *     variant: 'subtle',
+ *     colorField: 'statusColor',   // reads color from rowData.statusColor
+ *     badgeLabelField: 'statusLabel',
+ *   }
+ * }
+ * ```
+ */
+export declare const BadgeCellRenderer: {
+    (props: BadgeCellRendererProps): import("react/jsx-runtime").JSX.Element | null;
+    displayName: string;
+};

package/dist/components/data/ag-grid-react/cell-renderers/badge-cell-renderer.js

@@ -0,0 +1,23 @@
+import { jsx as d, jsxs as m } from "react/jsx-runtime";
+import { Badge as g } from "../../../data-display/badge/badge.js";
+import { getFieldValue as l, mapBadgeColor as f, mapBadgeVariant as u } from "./cell-renderer-utils.js";
+const h = (e) => {
+  const { data: i, value: n } = e, a = l(e.badgeLabelField, e.badgeLabel, i) ?? (n != null ? String(n) : void 0), c = l(e.variantField, e.variant, i) ?? "filled", r = l(e.colorField, e.color, i) ?? "default", o = l(e.isIconField, e.isIcon, i), t = l(e.iconField, e.icon, i), s = l(e.sizeField, e.size, i);
+  return a ? /* @__PURE__ */ d("div", { className: "w-full h-full flex items-center justify-start ag-cell-inner-padding", children: /* @__PURE__ */ d(
+    g,
+    {
+      variant: u(c),
+      color: f(r),
+      size: s === "small" ? "sm" : "md",
+      style: { fontSize: "inherit", lineHeight: "inherit" },
+      children: o && t ? /* @__PURE__ */ m("span", { className: "flex items-center gap-1", children: [
+        t,
+        a
+      ] }) : a
+    }
+  ) }) : null;
+};
+h.displayName = "BadgeCellRenderer";
+export {
+  h as BadgeCellRenderer
+};

package/dist/components/data/ag-grid-react/cell-renderers/editors/date-cell-editor.js

@@ -0,0 +1,87 @@
+import { jsx as w } from "react/jsx-runtime";
+import { forwardRef as O, useState as E, useImperativeHandle as $, useRef as M, useCallback as l, useEffect as L } from "react";
+import { Calendar as B } from "../../../../data-display/calendar/calendar.js";
+import { buildDateBoundsMatcher as F } from "../../../../../lib/date-bounds-matcher.js";
+const m = (a) => {
+  if (!(a == null || a === ""))
+    try {
+      const s = a instanceof Date ? a : new Date(String(a));
+      return isNaN(s.getTime()) ? void 0 : s;
+    } catch {
+      return;
+    }
+}, H = O((a, s) => {
+  const {
+    value: r,
+    min: f,
+    max: g,
+    node: u,
+    column: v,
+    stopEditing: h
+  } = a, c = r && typeof r == "object" && "value" in r, p = c ? r.cellMetadata : void 0, x = c ? r.value : r, b = m(x), [A, D] = E(b), [y, V] = E(b || /* @__PURE__ */ new Date());
+  $(s, () => ({
+    getValue() {
+      return r;
+    },
+    isCancelBeforeStart() {
+      return !1;
+    },
+    isCancelAfterEnd() {
+      return !1;
+    },
+    isPopup() {
+      return !0;
+    }
+  }));
+  const S = M(null), C = M(!1), i = l(() => {
+    C.current || (C.current = !0, h());
+  }, [h]);
+  L(() => {
+    const e = "ag-custom-component-popup", o = (n) => {
+      n instanceof HTMLElement && n.hasAttribute("data-radix-popper-content-wrapper") && n.classList.add(e);
+    }, t = new MutationObserver((n) => {
+      for (const I of n)
+        I.addedNodes.forEach(o);
+    });
+    return t.observe(document.body, { childList: !0, subtree: !0 }), document.querySelectorAll("[data-radix-popper-content-wrapper]").forEach((n) => {
+      n.classList.add(e);
+    }), () => t.disconnect();
+  }, []), L(() => {
+    const e = (o) => {
+      const t = o.target;
+      t && (S.current?.contains(t) || t.closest("[data-radix-popper-content-wrapper]") || t.closest(".ag-custom-component-popup") || i());
+    };
+    return document.addEventListener("mousedown", e), () => document.removeEventListener("mousedown", e);
+  }, [i]);
+  const d = l((e) => {
+    const o = v?.getColId();
+    if (o && u) {
+      const t = e ? `${e.getFullYear()}-${String(e.getMonth() + 1).padStart(2, "0")}-${String(e.getDate()).padStart(2, "0")}` : null, n = c ? { value: t, ...p !== void 0 && { cellMetadata: p } } : t;
+      u.setDataValue(o, n);
+    }
+    i();
+  }, [v, u, i, c, p]), N = l((e) => {
+    const o = e instanceof Date ? e : void 0;
+    D(o), d(o);
+  }, [d]), P = l(() => {
+    D(void 0), d(void 0);
+  }, [d]), R = f ? m(f) : void 0, j = g ? m(g) : void 0;
+  return /* @__PURE__ */ w("div", { ref: S, className: "ag-custom-component-popup bg-canvas-elevated border border-field rounded-md shadow-lg", children: /* @__PURE__ */ w(
+    B,
+    {
+      mode: "single",
+      selected: A,
+      onSelect: N,
+      month: y,
+      onMonthChange: V,
+      disabled: F(R, j),
+      showFooter: !1,
+      onClear: P,
+      captionLayout: "dropdown"
+    }
+  ) });
+});
+H.displayName = "DateCellEditor";
+export {
+  H as DateCellEditor
+};

package/dist/components/data/ag-grid-react/cell-renderers/editors/input-cell-editor.d.ts

@@ -0,0 +1,50 @@
+import { default as React } from 'react';
+import { ICellEditorParams } from 'ag-grid-community';
+/**
+ * Rule that describes how to generate the set of allowed autocomplete values.
+ * When provided via cellEditorParams.autocompleteRule (or cell metadata),
+ * the InputCellEditor switches to autocomplete mode: a dropdown of filtered
+ * suggestions appears below the input, and only dropdown values can be committed.
+ *
+ * Two variants:
+ *  - Numeric range: `{ min, max, step }` → generates e.g. 0, 5, 10, …, 100
+ *  - Static list:   `{ options }` → uses the string array as-is
+ */
+export type AutocompleteRule = {
+    min: number;
+    max: number;
+    step: number;
+    options?: never;
+} | {
+    options: string[];
+    min?: never;
+    max?: never;
+    step?: never;
+};
+export interface InputCellEditorHandle {
+    getValue(): unknown;
+    isCancelBeforeStart(): boolean;
+    isCancelAfterEnd(): boolean;
+}
+export interface InputCellEditorProps extends ICellEditorParams {
+    /** Placeholder text */
+    placeholder?: string;
+    /** Minimum value (number inputs) */
+    min?: number;
+    /** Maximum value (number inputs) */
+    max?: number;
+    /** Step increment (number inputs) */
+    step?: number;
+    /** Maximum character length */
+    maxLength?: number;
+    /** Whether to right-align (for numeric values) */
+    isNumeric?: boolean;
+    /** Optional callback when the value changes */
+    onValueChange?: (value: string | undefined) => void;
+    /** Whether to suppress auto-focus on mount */
+    suppressAutoFocus?: boolean;
+    /** When provided, enables autocomplete mode with a filtered dropdown of allowed values */
+    autocompleteRule?: AutocompleteRule;
+    className?: string;
+}
+export declare const InputCellEditor: React.NamedExoticComponent<InputCellEditorProps & React.RefAttributes<InputCellEditorHandle>>;