impact-nova 0.1.0

package/dist/components/ui/ag-grid-react/cell-renderers/checkbox-display-renderer.d.ts

@@ -0,0 +1,29 @@
+import { ICellRendererParams } from 'ag-grid-community';
+export interface CheckboxDisplayRendererProps extends ICellRendererParams {
+    /** Whether the checkbox is disabled */
+    disabled?: boolean;
+}
+/**
+ * CheckboxDisplayRenderer - Lightweight styled div that looks like a checkbox.
+ *
+ * Unlike Input/Select, checkboxes don't need a separate editor component.
+ * A single click toggles the boolean value directly via `node.setDataValue()`.
+ * This avoids the overhead of mounting/unmounting an editor for a simple toggle.
+ *
+ * Zero React state: the checked state is derived from `props.value`.
+ * AG Grid will re-render this component when the value changes.
+ *
+ * Usage in colDef:
+ * ```ts
+ * {
+ *   field: 'inStock',
+ *   cellRenderer: CheckboxDisplayRenderer,
+ *   editable: false,  // No AG Grid editor needed — toggle is handled in the renderer
+ *   cellRendererParams: { disabled: false },
+ * }
+ * ```
+ */
+export declare const CheckboxDisplayRenderer: {
+    (props: CheckboxDisplayRendererProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/components/ui/ag-grid-react/cell-renderers/checkbox-display-renderer.js

@@ -0,0 +1,36 @@
+import { jsx as a } from "react/jsx-runtime";
+import { useCallback as n } from "react";
+import { Check as h } from "lucide-react";
+const b = (c) => {
+  const { value: s, node: l, column: t, disabled: e } = c, r = !!s, o = n(() => {
+    e || !t || l.setDataValue(t.getColId(), !r);
+  }, [e, t, l, r]), d = n(
+    (i) => {
+      e || (i.key === " " || i.key === "Enter") && (i.preventDefault(), o());
+    },
+    [e, o]
+  );
+  return /* @__PURE__ */ a(
+    "div",
+    {
+      className: `flex items-center justify-center h-full w-full ag-cell-inner-padding ${e ? "opacity-60 cursor-not-allowed" : !e ? "ag-editable-cell-highlight" : ""}`,
+      onClick: o,
+      onKeyDown: d,
+      role: "checkbox",
+      "aria-checked": r,
+      "aria-disabled": e,
+      tabIndex: e ? -1 : 0,
+      children: /* @__PURE__ */ a(
+        "div",
+        {
+          className: `h-4 w-4 shrink-0 rounded-[4px] border flex items-center justify-center transition-colors ${r ? "border-primary bg-accent text-primary" : "border-tertiary-border bg-white"} ${e ? "cursor-not-allowed opacity-50" : "cursor-pointer"}`,
+          children: r && /* @__PURE__ */ a(h, { className: "h-3 w-3", strokeWidth: 3 })
+        }
+      )
+    }
+  );
+};
+b.displayName = "CheckboxDisplayRenderer";
+export {
+  b as CheckboxDisplayRenderer
+};

package/dist/components/ui/ag-grid-react/cell-renderers/date-display-renderer.d.ts

@@ -0,0 +1,37 @@
+import { ICellRendererParams } from 'ag-grid-community';
+export interface DateDisplayRendererProps extends ICellRendererParams {
+    /** Date format type: 'date' | 'datetime-local' | 'time' */
+    dateType?: 'date' | 'datetime-local' | 'time';
+    /** Placeholder text when no date is selected */
+    placeholder?: string;
+    /** Whether the field is disabled */
+    disabled?: boolean;
+}
+/**
+ * DateDisplayRenderer - Lightweight styled div showing a formatted date with a calendar icon.
+ *
+ * This is the DISPLAY component. It renders no `<input type="date">` element
+ * and holds zero React state. When clicked, AG Grid activates the paired
+ * `DateCellEditor` as a popup.
+ *
+ * Uses AG Grid's `valueFormatted` if a `valueFormatter` is configured on the
+ * colDef; otherwise falls back to locale-based date formatting.
+ *
+ * Usage in colDef:
+ * ```ts
+ * {
+ *   field: 'startDate',
+ *   cellRenderer: DateDisplayRenderer,
+ *   cellEditor: DateCellEditor,
+ *   cellEditorPopup: true,
+ *   editable: true,
+ *   singleClickEdit: true,
+ *   cellRendererParams: { dateType: 'date', placeholder: 'Select date...' },
+ *   cellEditorParams: { dateType: 'date' },
+ * }
+ * ```
+ */
+export declare const DateDisplayRenderer: {
+    (props: DateDisplayRendererProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/components/ui/ag-grid-react/cell-renderers/date-display-renderer.js

@@ -0,0 +1,50 @@
+import { jsx as r, jsxs as u } from "react/jsx-runtime";
+import { CalendarDays as m } from "lucide-react";
+const f = (e, i) => {
+  if (e == null || e === "") return "";
+  try {
+    const t = e instanceof Date ? e : new Date(String(e));
+    return isNaN(t.getTime()) ? String(e) : i === "time" ? t.toLocaleTimeString(void 0, { hour: "2-digit", minute: "2-digit" }) : i === "datetime-local" ? t.toLocaleString(void 0, {
+      year: "numeric",
+      month: "short",
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit"
+    }) : t.toLocaleDateString(void 0, {
+      year: "numeric",
+      month: "short",
+      day: "numeric"
+    });
+  } catch {
+    return String(e);
+  }
+}, h = (e) => {
+  const {
+    valueFormatted: i,
+    value: t,
+    dateType: d = "date",
+    placeholder: l = "Select date...",
+    disabled: n,
+    colDef: s
+  } = e, c = !n && s?.editable === !0, a = i ?? f(t, d), o = !a;
+  return /* @__PURE__ */ r(
+    "div",
+    {
+      className: `w-full h-full flex items-center ag-cell-inner-padding ${n ? "opacity-60 cursor-not-allowed" : c ? "ag-editable-cell-highlight" : ""}`,
+      children: /* @__PURE__ */ u(
+        "div",
+        {
+          className: "flex w-full items-center justify-between rounded-[8px] bg-white px-1.5 h-7 cursor-pointer",
+          children: [
+            /* @__PURE__ */ r("span", { className: `truncate text-sm font-medium text-[#1f2b4d] ${o ? "text-[#dfe2e7]" : ""}`, children: o ? l : a }),
+            /* @__PURE__ */ r(m, { className: "h-3.5 w-3.5 shrink-0 text-muted-foreground" })
+          ]
+        }
+      )
+    }
+  );
+};
+h.displayName = "DateDisplayRenderer";
+export {
+  h as DateDisplayRenderer
+};

package/dist/components/ui/ag-grid-react/cell-renderers/editors/date-cell-editor.d.ts

@@ -0,0 +1,33 @@
+import { ICellEditorParams } from 'ag-grid-community';
+export interface DateCellEditorProps extends ICellEditorParams {
+    /** Date input type */
+    dateType?: 'date' | 'datetime-local' | 'time';
+    /** Minimum date (ISO string) */
+    min?: string;
+    /** Maximum date (ISO string) */
+    max?: string;
+}
+/**
+ * DateCellEditor - AG Grid popup cell editor with a native date input.
+ *
+ * Uses the browser's native date picker for reliable cross-browser support.
+ * Mounted by AG Grid as a popup editor (requires `cellEditorPopup: true`).
+ *
+ * Returns an ISO string on commit, which AG Grid stores as the cell value.
+ *
+ * Only holds a single piece of state: the current date string.
+ *
+ * Usage in colDef:
+ * ```ts
+ * {
+ *   field: 'startDate',
+ *   cellRenderer: DateDisplayRenderer,
+ *   cellEditor: DateCellEditor,
+ *   cellEditorPopup: true,
+ *   editable: true,
+ *   singleClickEdit: true,
+ *   cellEditorParams: { dateType: 'date', min: '2020-01-01', max: '2030-12-31' },
+ * }
+ * ```
+ */
+export declare const DateCellEditor: import('react').ForwardRefExoticComponent<DateCellEditorProps & import('react').RefAttributes<unknown>>;

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

@@ -0,0 +1,73 @@
+import { jsx as c } from "react/jsx-runtime";
+import { forwardRef as h, useRef as y, useState as S, useImperativeHandle as b, useCallback as u } from "react";
+const w = (e, n) => {
+  if (e == null || e === "") return "";
+  try {
+    const t = e instanceof Date ? e : new Date(String(e));
+    return isNaN(t.getTime()) ? "" : n === "date" ? t.toISOString().split("T")[0] : n === "datetime-local" ? t.toISOString().slice(0, 16) : n === "time" ? t.toISOString().slice(11, 16) : "";
+  } catch {
+    return "";
+  }
+}, C = h((e, n) => {
+  const {
+    value: t,
+    dateType: a = "date",
+    min: l,
+    max: d,
+    stopEditing: s
+  } = e, i = y(null), [o, f] = S(w(t, a));
+  b(n, () => ({
+    getValue() {
+      if (!o) return null;
+      if (a === "time") return o;
+      try {
+        return new Date(o).toISOString();
+      } catch {
+        return o;
+      }
+    },
+    isCancelBeforeStart() {
+      return !1;
+    },
+    isCancelAfterEnd() {
+      return !1;
+    },
+    isPopup() {
+      return !0;
+    },
+    afterGuiAttached() {
+      if (i.current) {
+        i.current.focus();
+        try {
+          i.current.showPicker?.();
+        } catch {
+        }
+      }
+    }
+  }));
+  const p = u((r) => {
+    f(r.target.value);
+  }, []), m = u((r) => {
+    r.key === "Enter" || r.key === "Escape" || r.key === "Tab" || r.stopPropagation();
+  }, []), g = u(() => {
+    s();
+  }, [s]);
+  return /* @__PURE__ */ c("div", { className: "p-1 bg-white border border-primary rounded-md shadow-lg", children: /* @__PURE__ */ c(
+    "input",
+    {
+      ref: i,
+      type: a,
+      value: o,
+      onChange: p,
+      onKeyDown: m,
+      onBlur: g,
+      min: l,
+      max: d,
+      className: "px-2 py-1.5 text-sm font-medium bg-white border border-input rounded focus:outline-none focus:border-primary cursor-pointer"
+    }
+  ) });
+});
+C.displayName = "DateCellEditor";
+export {
+  C as DateCellEditor
+};

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

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+import { ICellEditorParams } from 'ag-grid-community';
+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;
+}
+export declare const InputCellEditor: React.NamedExoticComponent<InputCellEditorProps & React.RefAttributes<any>>;

package/dist/components/ui/ag-grid-react/cell-renderers/editors/input-cell-editor.js

@@ -0,0 +1,91 @@
+import { jsx as o } from "react/jsx-runtime";
+import C, { forwardRef as A, useRef as E, useImperativeHandle as V, useEffect as D, useCallback as s } from "react";
+const p = A((u, m) => {
+  const {
+    value: i,
+    placeholder: h,
+    min: g,
+    max: b,
+    step: w,
+    maxLength: a,
+    onValueChange: c,
+    colDef: x
+  } = u, f = x?.cellDataType === "number" ? "number" : "text", l = f === "number", t = E(null);
+  V(m, () => ({
+    getValue() {
+      const e = t.current?.value;
+      if (l) {
+        if (!e || e === "" || e === "-")
+          return null;
+        const d = Number(e);
+        return isNaN(d) ? null : d;
+      }
+      return e === "" ? null : e;
+    },
+    isCancelBeforeStart() {
+      return !1;
+    },
+    isCancelAfterEnd() {
+      return !1;
+    }
+  }), []), D(() => {
+    if (t.current && !u.suppressAutoFocus) {
+      if (t.current.value = i != null ? String(i) : "", l) {
+        const n = t.current, e = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value");
+        Object.defineProperty(n, "value", {
+          get() {
+            const r = this.valueAsNumber;
+            return isNaN(r) ? e.get.call(this) : r;
+          },
+          set(r) {
+            e.set.call(this, r);
+          },
+          configurable: !0
+        });
+      }
+      t.current.focus(), t.current.select();
+    }
+    return () => {
+    };
+  }, []);
+  const y = s((n) => {
+    const e = t.current?.value;
+    if (!(a && e && e.length > a)) {
+      if (l && t.current) {
+        const r = t.current.valueAsNumber;
+        isNaN(r) || t.current.setAttribute("data-value", String(r));
+      }
+      c?.(e);
+    }
+  }, [a, c, l]), N = s((n) => {
+    n.key === "Enter" || n.key === "Escape" || n.key === "Tab" || ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"].includes(n.key) && n.stopPropagation();
+  }, []), v = s(() => {
+    u.stopEditing?.();
+  }, [u, l]);
+  return /* @__PURE__ */ o("div", { className: "w-full h-full flex items-center ag-cell-inner-padding ag-editable-cell-highlight", children: /* @__PURE__ */ o(
+    "div",
+    {
+      className: `flex w-full items-center rounded-[8px] bg-white px-1.5 h-7 ${l ? "justify-end text-right" : ""}`,
+      children: /* @__PURE__ */ o(
+        "input",
+        {
+          ref: t,
+          type: f,
+          onChange: y,
+          onKeyDown: N,
+          onBlur: v,
+          placeholder: h,
+          className: `flex h-full w-full bg-transparent p-0 text-sm font-medium text-[#1f2b4d] outline-none placeholder:font-medium placeholder:text-[#dfe2e7] ${l ? "text-right" : ""}`,
+          min: g,
+          max: b,
+          step: w
+        }
+      )
+    }
+  ) });
+});
+p.displayName = "InputCellEditor";
+const R = C.memo(p, () => !0);
+export {
+  R as InputCellEditor
+};

package/dist/components/ui/ag-grid-react/cell-renderers/editors/select-cell-editor.d.ts

@@ -0,0 +1,45 @@
+import { ICellEditorParams } from 'ag-grid-community';
+import { SelectOption } from '../types';
+export interface SelectCellEditorProps extends ICellEditorParams {
+    /** Available options */
+    options?: SelectOption[];
+    /** Placeholder text */
+    placeholder?: string;
+    /** Whether the dropdown is searchable */
+    isSearchable?: boolean;
+    /** Whether the value can be cleared */
+    isClearable?: boolean;
+    /** Optional callback when value changes */
+    onValueChange?: (value: string | null) => void;
+}
+/**
+ * SelectCellEditor - AG Grid cell editor using impact-nova's Select component.
+ *
+ * Mounted by AG Grid when a cell enters edit mode. The Select dropdown opens
+ * automatically on mount so the user doesn't need a second click.
+ *
+ * The editor visually matches the SelectDisplayRenderer — same outer wrapper
+ * with `ag-editable-cell-highlight`, same inner white rounded div with chevron.
+ * The Select trigger is styled to blend in seamlessly.
+ *
+ * Only holds a single piece of state: the currently selected value.
+ *
+ * Usage in colDef:
+ * ```ts
+ * {
+ *   field: 'status',
+ *   cellRenderer: SelectDisplayRenderer,
+ *   cellEditor: SelectCellEditor,
+ *   cellEditorPopup: true,
+ *   editable: true,
+ *   singleClickEdit: true,
+ *   cellEditorParams: {
+ *     options: [
+ *       { label: 'Active', value: 'active' },
+ *       { label: 'Inactive', value: 'inactive' },
+ *     ],
+ *   },
+ * }
+ * ```
+ */
+export declare const SelectCellEditor: import('react').ForwardRefExoticComponent<SelectCellEditorProps & import('react').RefAttributes<unknown>>;

package/dist/components/ui/ag-grid-react/cell-renderers/editors/select-cell-editor.js

@@ -0,0 +1,64 @@
+import { jsx as d } from "react/jsx-runtime";
+import { forwardRef as v, useState as x, useRef as E, useImperativeHandle as V, useCallback as n } from "react";
+import M from "../../../select/select.js";
+const N = v((t, f) => {
+  const {
+    value: a,
+    options: p = [],
+    placeholder: g = "Select...",
+    isSearchable: h = !0,
+    isClearable: m = !0,
+    stopEditing: s
+  } = t, r = p.map((e) => ({
+    value: e.value,
+    label: e.label,
+    isDisabled: e.isDisabled
+  })), [u, o] = x(
+    a != null ? String(a) : null
+  ), i = E(!1);
+  V(f, () => ({
+    getValue() {
+      return u;
+    },
+    isCancelBeforeStart() {
+      return !1;
+    },
+    isCancelAfterEnd() {
+      return !1;
+    },
+    isPopup() {
+      return !0;
+    }
+  }));
+  const C = r.find((e) => e.value === u) ?? null, l = n(() => {
+    i.current || (i.current = !0, s());
+  }, [s]), S = n(
+    (e) => {
+      const c = e ? e.value : null;
+      o(c), t.onValueChange?.(c), l();
+    },
+    [l, o, t.onValueChange]
+  ), b = n(() => {
+    l();
+  }, [l]);
+  return /* @__PURE__ */ d("div", { className: "w-full h-full flex items-center ag-cell-inner-padding ag-editable-cell-highlight", children: /* @__PURE__ */ d(
+    M,
+    {
+      options: r,
+      value: C,
+      onChange: S,
+      onMenuClose: b,
+      placeholder: g,
+      isSearchable: h,
+      isClearable: m,
+      isMulti: !1,
+      defaultMenuIsOpen: !0,
+      className: "!border-none !shadow-none !ring-0 !h-7 !rounded-[8px] !px-1.5",
+      parentClassName: "!w-full !gap-0"
+    }
+  ) });
+});
+N.displayName = "SelectCellEditor";
+export {
+  N as SelectCellEditor
+};

package/dist/components/ui/ag-grid-react/cell-renderers/editors/split-cell-editor.d.ts

@@ -0,0 +1,9 @@
+import { ICellEditorParams } from 'ag-grid-community';
+import { SplitConfig, SubCellComponentProps } from '../types';
+export interface SplitCellEditorProps extends Omit<ICellEditorParams, 'context'> {
+    splits: SplitConfig[];
+    context?: {
+        frameworkComponents?: Record<string, React.ComponentType<SubCellComponentProps>>;
+    };
+}
+export declare const SplitCellEditor: import('react').ForwardRefExoticComponent<SplitCellEditorProps & import('react').RefAttributes<unknown>>;

package/dist/components/ui/ag-grid-react/cell-renderers/editors/split-cell-editor.js

@@ -0,0 +1,85 @@
+import { jsx as s } from "react/jsx-runtime";
+import { forwardRef as b, useRef as R, useImperativeHandle as v } from "react";
+import { AG_GRID_VALUE_FORMATTERS as x } from "../../value-formatters.js";
+const N = b((m, g) => {
+  const { splits: a, data: f, node: h, api: u, column: d, context: p, stopEditing: y } = m, i = R({});
+  Object.keys(i.current).length === 0 && a && f && a.forEach((e) => {
+    const o = e.field.split(".");
+    let r = f;
+    for (const t of o) r = r?.[t];
+    i.current[e.field] = r && typeof r == "object" && "value" in r ? r.value : r;
+  }), v(g, () => ({
+    getValue() {
+      const e = JSON.parse(JSON.stringify(f));
+      return Object.entries(i.current).forEach(([o, r]) => {
+        const t = o.split(".");
+        let l = e;
+        for (let n = 0; n < t.length - 1; n++)
+          l[t[n]] || (l[t[n]] = {}), l = l[t[n]];
+        l[t[t.length - 1]] = r;
+      }), e;
+    },
+    isCancelBeforeStart: () => !1,
+    isCancelAfterEnd: () => !1,
+    isPopup: () => !1
+  }));
+  const C = d?.getColDef().type === "number", E = (e, o, r) => {
+    const t = e.valueFormatter;
+    if (!t) return o;
+    if (typeof t == "function")
+      return t({ value: o, data: r });
+    const l = typeof t == "string" ? t : t.type, n = x[l];
+    if (n) {
+      const c = {
+        value: o,
+        data: r,
+        node: h,
+        api: u,
+        context: p,
+        column: d,
+        colDef: {
+          ...d?.getColDef(),
+          ...typeof t == "object" ? t : {},
+          ...e
+        }
+      };
+      return n(c);
+    }
+    return o;
+  };
+  return /* @__PURE__ */ s("div", { style: { display: "grid", gridTemplateRows: `repeat(${a.length}, 1fr)`, height: "100%", width: "100%" }, children: a.map((e, o) => {
+    let r = e.cellEditor || e.cellRenderer;
+    if (typeof r == "string") {
+      const c = u?.getGridOption("components");
+      r = p?.frameworkComponents?.[r] || c?.[r];
+    }
+    const t = e.type === "number" || e.type !== "text" && C, l = i.current[e.field], n = r;
+    return /* @__PURE__ */ s(
+      "div",
+      {
+        className: `flex items-center min-h-0 max-h-full overflow-hidden ${t ? "justify-end" : ""}`,
+        style: { borderBottom: o === a.length - 1 ? "none" : "1px solid #d9dde7" },
+        children: e.editable && n ? /* @__PURE__ */ s(
+          n,
+          {
+            ...m,
+            ...e.cellEditorParams,
+            ...e.cellRendererParams,
+            value: l,
+            onValueChange: (c) => {
+              i.current[e.field] = c;
+            },
+            suppressAutoFocus: o !== 0,
+            colDef: { ...e, field: e.field },
+            stopEditing: y
+          }
+        ) : /* @__PURE__ */ s("div", { className: `w-full px-2 text-gray-500 ${t ? "text-right" : ""}`, children: E(e, l, f) })
+      },
+      o
+    );
+  }) });
+});
+N.displayName = "SplitCellEditor";
+export {
+  N as SplitCellEditor
+};

package/dist/components/ui/ag-grid-react/cell-renderers/editors/textarea-cell-editor.d.ts

@@ -0,0 +1,31 @@
+import { ICellEditorParams } from 'ag-grid-community';
+export interface TextAreaCellEditorProps extends ICellEditorParams {
+    /** Number of visible rows */
+    rows?: number;
+    /** Maximum character length */
+    maxLength?: number;
+    /** Placeholder text */
+    placeholder?: string;
+}
+/**
+ * TextAreaCellEditor - AG Grid popup cell editor with a native textarea.
+ *
+ * Mounted by AG Grid as a popup editor (requires `cellEditorPopup: true` in colDef).
+ * This allows the textarea to expand beyond the cell boundaries.
+ *
+ * Only holds a single piece of state: the current text value.
+ *
+ * Usage in colDef:
+ * ```ts
+ * {
+ *   field: 'description',
+ *   cellRenderer: TextAreaDisplayRenderer,
+ *   cellEditor: TextAreaCellEditor,
+ *   cellEditorPopup: true,
+ *   editable: true,
+ *   singleClickEdit: true,
+ *   cellEditorParams: { rows: 4, maxLength: 500, placeholder: 'Enter description...' },
+ * }
+ * ```
+ */
+export declare const TextAreaCellEditor: import('react').ForwardRefExoticComponent<TextAreaCellEditorProps & import('react').RefAttributes<unknown>>;

package/dist/components/ui/ag-grid-react/cell-renderers/editors/textarea-cell-editor.js

@@ -0,0 +1,61 @@
+import { jsxs as l, jsx as h } from "react/jsx-runtime";
+import { forwardRef as g, useRef as x, useState as y, useImperativeHandle as w, useCallback as u } from "react";
+const b = g((s, i) => {
+  const {
+    value: a,
+    rows: d = 4,
+    maxLength: t,
+    placeholder: c
+  } = s, r = x(null), [n, f] = y(a != null ? String(a) : "");
+  w(i, () => ({
+    getValue() {
+      return n;
+    },
+    isCancelBeforeStart() {
+      return !1;
+    },
+    isCancelAfterEnd() {
+      return !1;
+    },
+    isPopup() {
+      return !0;
+    },
+    afterGuiAttached() {
+      if (r.current) {
+        r.current.focus();
+        const e = r.current.value.length;
+        r.current.setSelectionRange(e, e);
+      }
+    }
+  }));
+  const m = u((e) => {
+    const o = e.target.value;
+    t && o.length > t || f(o);
+  }, [t]), p = u((e) => {
+    e.key !== "Escape" && e.key !== "Tab" && (e.key === "Enter" && !e.shiftKey || e.stopPropagation());
+  }, []);
+  return /* @__PURE__ */ l("div", { className: "p-1 bg-white border border-primary rounded-md shadow-lg min-w-[250px]", children: [
+    /* @__PURE__ */ h(
+      "textarea",
+      {
+        ref: r,
+        value: n,
+        onChange: m,
+        onKeyDown: p,
+        placeholder: c,
+        rows: d,
+        maxLength: t,
+        className: "w-full px-2 py-1.5 text-sm font-medium bg-white border border-input rounded focus:outline-none focus:border-primary resize-y"
+      }
+    ),
+    t && /* @__PURE__ */ l("div", { className: "text-right text-xs text-muted-foreground px-1 mt-0.5", children: [
+      n.length,
+      "/",
+      t
+    ] })
+  ] });
+});
+b.displayName = "TextAreaCellEditor";
+export {
+  b as TextAreaCellEditor
+};