impact-nova 2.0.9 → 2.1.0-alpha.10

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

@@ -0,0 +1,106 @@
+import { jsx as C } from "react/jsx-runtime";
+import { forwardRef as z, useState as F, useImperativeHandle as B, useEffect as H, useMemo as L, useCallback as M } from "react";
+import { resolveValueFormatter as q, applyValueFormatter as J, resolveCellEditable as I } from "../cell-renderer-utils.js";
+import { initializeSplitCellFocusSession as Q } from "./split-cell-focus.js";
+function X() {
+  return document;
+}
+function Y(p, w, a, u, r) {
+  const n = a, s = typeof u?.editable == "boolean" ? u.editable : void 0, f = p[w], i = f?.field?.split(".")?.pop(), l = i ? r?.[i] : void 0;
+  return I(s, f?.editable, n, l);
+}
+const Z = z((p, w) => {
+  const { splits: a, commonParams: u, data: r, node: n, api: s, column: f, context: i, value: l, colDef: o, valueFormatter: U, eventKey: D } = p, [N] = F(() => {
+    const e = p.eGridCell;
+    return Q({
+      cellElement: e,
+      splits: a,
+      eventKey: D,
+      data: r,
+      colDef: o,
+      value: l,
+      documentState: X(),
+      resolveSplitEditable: Y
+    });
+  }), { targetSplitIndex: k, isKeyboardEntry: A, lastWasEditable: P, targetIsNonEditable: R } = N, v = R || A && !P;
+  B(w, () => ({
+    getValue() {
+      const e = o?.field;
+      return e && n?.data ? n.data[e] : l;
+    },
+    isCancelBeforeStart() {
+      return v;
+    },
+    isCancelAfterEnd() {
+      return !1;
+    }
+  }), [o, n, l, v]), H(() => {
+    v && setTimeout(() => {
+      s?.stopEditing();
+    }, 0);
+  }, [v, s]);
+  const j = L(() => a?.map((e) => {
+    const t = e?.field?.split(".")?.pop() ?? "", d = l?.[t]?.value;
+    return { valueKey: t, field: e.field, newValue: d };
+  }) ?? [], [a, l]), [g, O] = F(j), $ = M((e) => {
+    const t = g.find((b) => b.field === e);
+    if (!t || !o.field) return;
+    const d = l?.[t.valueKey]?.value;
+    if (String(t.newValue ?? "") === String(d ?? ""))
+      return;
+    document.__splitCellLastWasEditable = !0;
+    const c = {
+      api: s,
+      colDef: o,
+      column: f,
+      context: i,
+      data: r,
+      field: o.field,
+      node: n,
+      rowIndex: n?.rowIndex ?? null,
+      rowPinned: n?.rowPinned ?? void 0,
+      source: "edit",
+      type: "cellValueChanged",
+      currentCellUpdate: t,
+      newValue: { [t.valueKey]: { value: t.newValue } },
+      oldValue: { [t.valueKey]: { value: l?.[t.valueKey]?.value } },
+      value: { [t.valueKey]: { value: t.newValue } }
+    }, m = l?.[t.valueKey] ?? {};
+    n.setDataValue(o.field, { ...l, [t.valueKey]: { ...m, value: t.newValue } }), i?.onCellUpdate?.(c);
+  }, [g, s, o, f, i, r, n, l]), G = (e) => {
+    if (typeof e == "string") {
+      const t = s?.getGridOption("components");
+      return i?.frameworkComponents?.[e] || t?.[e];
+    }
+    return e;
+  };
+  return /* @__PURE__ */ C("div", { style: { display: "grid", gridTemplateRows: `repeat(${a?.length}, 1fr)`, height: "100%", width: "100%" }, children: a?.map((e, t) => {
+    const d = e?.field?.split(".")?.pop();
+    if (!d) return null;
+    const c = l?.[d], m = c?.value, b = r, V = q(c, b, e?.valueFormatter, U ?? null), h = V ? J(V, m) : m?.toString(), T = typeof o?.editable == "boolean" ? o.editable : void 0, y = I(T, e.editable, b, c), W = t === k && y, E = y ? u?.cellEditor ?? u?.cellRenderer : u?.cellRenderer ?? void 0, S = E ? G(E) : void 0;
+    return /* @__PURE__ */ C("div", { className: "flex items-center max-h-full overflow-hidden", children: S ? /* @__PURE__ */ C(
+      S,
+      {
+        context: i,
+        data: r,
+        value: c,
+        onValueChange: (x) => {
+          const K = g.find((_) => _.field === e.field);
+          K ? K.newValue = x : O([...g, { valueKey: d, field: e.field, newValue: x }]);
+        },
+        valueFormatted: h ?? void 0,
+        colDef: { ...e, editable: y },
+        stopEditing: () => {
+          $(e.field);
+        },
+        node: n,
+        suppressAutoFocus: !W,
+        className: t !== a.length - 1 ? "border-b border-stroke-hairline" : ""
+      }
+    ) : /* @__PURE__ */ C("div", { className: "w-full h-full flex items-center ag-cell-inner-padding overflow-hidden text-ellipsis whitespace-nowrap", children: String(h ?? m ?? "") }) }, `${e.field}-${t}`);
+  }) });
+});
+Z.displayName = "SplitCellEditor";
+export {
+  Z as SplitCellEditor
+};

package/dist/components/data/ag-grid-react/cell-renderers/editors/split-cell-focus.d.ts

@@ -0,0 +1,53 @@
+import { ColDef } from 'ag-grid-enterprise';
+import { SplitConfig, SplitCellValue } from '../types';
+export type SplitCellDocumentState = {
+    __splitCellLastClickY?: number;
+    __splitCellLastActiveIndex?: number;
+    __splitCellLastWasEditable?: boolean;
+};
+/**
+ * True when edit was started by keyboard (Enter/F2/type-to-edit), not mouse click.
+ * eventKey wins over stale __splitCellLastClickY left by a prior mousedown that did not edit.
+ */
+export declare function isSplitCellKeyboardEntry(eventKey: string | null | undefined, documentState: SplitCellDocumentState): boolean;
+/**
+ * Call from colDef.suppressKeyboardEvent before AG Grid evaluates editable().
+ * Clears stale click coordinates so Enter/F2/type-to-edit use keyboard focus rules.
+ */
+export declare function prepareSplitCellKeyboardEditStart(eventKey: string, isEditing: boolean): void;
+export type SplitCellFocusMeta = {
+    index: number;
+    wasEditable: boolean;
+    clearClickY: boolean;
+    activeIndex?: number;
+};
+type ResolveSplitEditable = (splits: SplitConfig[], index: number, data: unknown, colDef: ColDef | undefined, value: SplitCellValue | undefined) => boolean;
+export declare function computeSplitCellFocusMeta(options: {
+    cellElement?: HTMLElement;
+    splits?: SplitConfig[];
+    isKeyboardEntry: boolean;
+    eventKey: string | null | undefined;
+    data: unknown;
+    colDef: ColDef | undefined;
+    value: SplitCellValue | undefined;
+    documentState: SplitCellDocumentState;
+    resolveSplitEditable: ResolveSplitEditable;
+}): SplitCellFocusMeta;
+export type SplitCellFocusSession = {
+    targetSplitIndex: number;
+    isKeyboardEntry: boolean;
+    lastWasEditable: boolean;
+    targetIsNonEditable: boolean;
+};
+export declare function initializeSplitCellFocusSession(options: {
+    cellElement?: HTMLElement;
+    splits?: SplitConfig[];
+    eventKey: string | null | undefined;
+    data: unknown;
+    colDef: ColDef | undefined;
+    value: SplitCellValue | undefined;
+    documentState: SplitCellDocumentState;
+    resolveSplitEditable: ResolveSplitEditable;
+}): SplitCellFocusSession;
+export declare function applySplitCellFocusMeta(documentState: SplitCellDocumentState, focusMeta: SplitCellFocusMeta): void;
+export {};

package/dist/components/data/ag-grid-react/cell-renderers/editors/split-cell-focus.js

@@ -0,0 +1,98 @@
+function x(e, l) {
+  return e != null && e !== "" ? !0 : l.__splitCellLastClickY == null;
+}
+function _(e, l, a, n, s, i) {
+  for (let t = 0; t < e.length; t++)
+    if (s(e, t, l, a, n))
+      return i.__splitCellLastActiveIndex = t, i.__splitCellLastWasEditable = !0, { index: t, wasEditable: !0, clearClickY: !1 };
+  return i.__splitCellLastWasEditable = !1, { index: 0, wasEditable: !1, clearClickY: !1 };
+}
+function b(e, l, a, n, s, i) {
+  const t = i.__splitCellLastActiveIndex;
+  if (t != null && t >= 0 && t < e.length) {
+    const r = s(e, t, l, a, n);
+    return i.__splitCellLastWasEditable = r, { index: t, wasEditable: r, clearClickY: !1 };
+  }
+  return _(e, l, a, n, s, i);
+}
+function p(e, l, a, n, s, i, t) {
+  const r = t.__splitCellLastClickY;
+  if (r == null)
+    return { index: 0, wasEditable: !0, clearClickY: !1 };
+  const c = e.getBoundingClientRect(), d = r - c.top, u = c.height / l.length, f = Math.floor(d / u), C = Math.max(0, Math.min(f, l.length - 1)), o = i(l, C, a, n, s);
+  return t.__splitCellLastClickY = void 0, t.__splitCellLastActiveIndex = C, t.__splitCellLastWasEditable = o, {
+    index: C,
+    wasEditable: o,
+    clearClickY: !1,
+    activeIndex: void 0
+  };
+}
+function E(e) {
+  const {
+    cellElement: l,
+    splits: a,
+    isKeyboardEntry: n,
+    eventKey: s,
+    data: i,
+    colDef: t,
+    value: r,
+    documentState: c,
+    resolveSplitEditable: d
+  } = e;
+  return !l || !a?.length ? { index: 0, wasEditable: !0, clearClickY: !1 } : n ? s === "Tab" ? b(
+    a,
+    i,
+    t,
+    r,
+    d,
+    c
+  ) : _(
+    a,
+    i,
+    t,
+    r,
+    d,
+    c
+  ) : p(
+    l,
+    a,
+    i,
+    t,
+    r,
+    d,
+    c
+  );
+}
+const L = {
+  index: 0,
+  wasEditable: !0,
+  clearClickY: !1
+};
+function k(e) {
+  const { documentState: l, eventKey: a } = e, n = x(a, l);
+  n && (l.__splitCellLastClickY = void 0);
+  const s = l.__splitCellLastWasEditable !== !1;
+  let i = L;
+  try {
+    i = E({
+      ...e,
+      isKeyboardEntry: n
+    }), v(l, i);
+  } catch {
+  }
+  return {
+    targetSplitIndex: i.index,
+    isKeyboardEntry: n,
+    lastWasEditable: s,
+    targetIsNonEditable: !i.wasEditable
+  };
+}
+function v(e, l) {
+  l.clearClickY && (e.__splitCellLastClickY = void 0), l.activeIndex != null && (e.__splitCellLastActiveIndex = l.activeIndex), e.__splitCellLastWasEditable = l.wasEditable;
+}
+export {
+  v as applySplitCellFocusMeta,
+  E as computeSplitCellFocusMeta,
+  k as initializeSplitCellFocusSession,
+  x as isSplitCellKeyboardEntry
+};

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

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

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

@@ -0,0 +1,9 @@
+/**
+ * EmptyCellRenderer - Returns null.
+ * Used for group rows or cells that should not display any content.
+ * Zero overhead: no state, no DOM elements.
+ */
+export declare const EmptyCellRenderer: {
+    (): null;
+    displayName: string;
+};

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

@@ -0,0 +1,5 @@
+const e = () => null;
+e.displayName = "EmptyCellRenderer";
+export {
+  e as EmptyCellRenderer
+};

package/dist/components/data/ag-grid-react/cell-renderers/link-with-batch-cell-renderer.js

@@ -0,0 +1,148 @@
+import { jsx as c, jsxs as w } from "react/jsx-runtime";
+import { useMemo as x, useCallback as T } from "react";
+import { Badge as V } from "../../../data-display/badge/badge.js";
+import { evaluateValidationRules as I, getFieldValue as m, mapBadgeVariant as L, mapBadgeColor as U } from "./cell-renderer-utils.js";
+import { resolveGridIcon as H } from "./gridIconResolver.js";
+import { Tooltip as _, TooltipTrigger as z, TooltipContent as G } from "../../../feedback/tooltip/tooltip.js";
+const M = (e, n, r, a) => {
+  if (!n) return e;
+  let l = e;
+  return l = l.replace(/\$\{value\}/g, String(a ?? "")), l = l.replace(/\$\{field\}/g, String(r ?? "")), Object.keys(n).forEach((i) => {
+    const o = new RegExp(`\\$\\{${i}\\}`, "g");
+    l = l.replace(o, String(n[i] ?? ""));
+  }), l;
+}, Q = ({
+  iconConfig: e,
+  rowData: n,
+  rowId: r,
+  field: a
+}) => {
+  let l = null;
+  const i = m(e.iconField, e.icon, n);
+  if (typeof i == "string" ? l = H(i, { size: 16 }) : l = i, !l) return null;
+  const o = m(e.backgroundColorField, e.backgroundColor, n), s = m(e.colorField, e.color, n) ?? "var(--color-foreground-icon)", f = m(e.tooltipField, e.tooltip, n), g = /* @__PURE__ */ c(
+    "div",
+    {
+      className: `flex items-center justify-center bg-[var(--icon-bg)] text-[var(--icon-fg)] ${e.onClick ? "cursor-pointer" : ""} ${e.showOnHover ? "opacity-0 group-hover:opacity-100 transition-opacity" : ""}`,
+      style: {
+        "--icon-bg": o,
+        "--icon-fg": s,
+        borderRadius: "4px",
+        padding: "2px",
+        minWidth: "18px",
+        minHeight: "18px"
+      },
+      onClick: e.onClick ? () => e.onClick?.({ rowId: r, field: a, rowData: n ?? {} }) : void 0,
+      children: l
+    }
+  );
+  return f ? /* @__PURE__ */ w(_, { children: [
+    /* @__PURE__ */ c(z, { asChild: !0, children: g }),
+    /* @__PURE__ */ c(G, { variant: "tertiary", side: e.tooltipSide || "top", children: f })
+  ] }) : null;
+}, W = ({
+  badgeConfig: e,
+  rowData: n,
+  rowId: r,
+  field: a
+}) => {
+  const l = m(e.labelField, e.label, n);
+  if (!l) return null;
+  const i = m(e.colorField, e.color, n), o = m(e.variantField, e.variant, n);
+  return /* @__PURE__ */ c(
+    V,
+    {
+      className: "font-medium",
+      color: U(i),
+      variant: L(o),
+      onClick: e.onClick ? () => e.onClick?.({ rowId: r, field: a, rowData: n ?? {} }) : void 0,
+      children: l
+    }
+  );
+}, q = (e) => {
+  const {
+    value: n,
+    data: r,
+    node: a,
+    colDef: l,
+    onClick: i,
+    redirectUrl: o,
+    updateQueryParams: s,
+    navigate: f,
+    setSearchParams: g,
+    rightSideContent: y,
+    valueFormatter: k,
+    disableOnPinnedRows: S = !0,
+    disableLinkStyle: $,
+    validationRules: R
+  } = e, v = a.id ?? String(r?.id ?? ""), d = l?.field ?? "", E = r && typeof r == "object" && "_isPinned" in r && r._isPinned === !0, F = x(() => $ || S && E || I(R, r) ? !1 : !!(s || o || i), [$, S, E, s, o, i, R, r]), N = T(
+    (u) => {
+      if (u.stopPropagation(), s && g)
+        g((t) => {
+          const h = new URLSearchParams(t);
+          return Object.entries(s).forEach(([b, C]) => {
+            let p = String(C);
+            p = p.replace(/\$\{value\}/g, String(n ?? "")), p = p.replace(/\$\{field\}/g, d), r && Object.keys(r).forEach((j) => {
+              const O = new RegExp(`\\$\\{${j}\\}`, "g");
+              p = p.replace(O, String(r[j] ?? ""));
+            }), h.set(b, p);
+          }), h;
+        });
+      else if (o && f) {
+        const t = M(o, r, d, n);
+        f(t);
+      } else i && i({ rowId: v, field: d, rowData: r ?? {}, value: n });
+    },
+    [s, g, o, f, i, r, d, n, v]
+  ), B = x(() => k ? k(n, r ?? {}) : String(n ?? ""), [n, k, r]), P = x(() => {
+    if (!y?.items || y.items.length === 0) return null;
+    const u = [];
+    return y.items.forEach((t, h) => {
+      if (t.type === "icon" && t.icon)
+        u.push(
+          /* @__PURE__ */ c(
+            Q,
+            {
+              iconConfig: t.icon,
+              rowData: r,
+              rowId: v,
+              field: d
+            },
+            `icon-${h}`
+          )
+        );
+      else if (t.type === "badge" && t.badge)
+        u.push(
+          /* @__PURE__ */ c(
+            W,
+            {
+              badgeConfig: t.badge,
+              rowData: r,
+              rowId: v,
+              field: d
+            },
+            `badge-${h}`
+          )
+        );
+      else if (t.type === "dynamic" && t.dynamic) {
+        const b = typeof t.dynamic == "function" ? t.dynamic(r ?? {}) : t.dynamic;
+        u.push(/* @__PURE__ */ c("span", { children: b }, `dyn-${h}`));
+      }
+    }), u.length > 0 ? u : null;
+  }, [y, r, v, d]);
+  return /* @__PURE__ */ w("div", { className: "w-full h-full flex items-center justify-between gap-2 group ag-cell-inner-padding", children: [
+    /* @__PURE__ */ c(
+      "div",
+      {
+        className: `flex-1 truncate min-w-0 ${F ? "text-brand cursor-pointer hover:underline font-medium" : ""}`,
+        onClick: F ? N : void 0,
+        children: B
+      }
+    ),
+    P && /* @__PURE__ */ c("div", { className: "flex items-center gap-1 flex-shrink-0", children: P })
+  ] });
+};
+q.displayName = "LinkCellRenderer";
+export {
+  q as LinkCellRenderer
+};

package/dist/components/data/ag-grid-react/cell-renderers/percent-progress-display-renderer.d.ts

@@ -0,0 +1,31 @@
+import { ICellRendererParams } from 'ag-grid-enterprise';
+import { BadgeProps } from '../../../data-display/badge';
+import { ProgressProps } from '../../../primitives/progress/progress';
+export interface PercentProgressDisplayRendererProps extends ICellRendererParams {
+    disabled?: boolean;
+    className?: string;
+    /** Inclusive min for the scale (default 0) */
+    min?: number;
+    /** Inclusive max for the scale (default 100) */
+    max?: number;
+    /** Decimal places for the badge label (default 0) */
+    fractionDigits?: number;
+    /** Percentage pill — same options as `Badge` (defaults: subtle / neutral / circle) */
+    badgeVariant?: BadgeProps['variant'];
+    badgeColor?: BadgeProps['color'];
+    badgeShape?: BadgeProps['shape'];
+    /** Progress track + fill — same options as `ProgressBar` / `Progress` (default: default) */
+    progressVariant?: ProgressProps['variant'];
+}
+/**
+ * PercentProgressDisplayRenderer — capsule progress bar + percentage pill (display).
+ * Pair with `PercentProgressCellEditor` via `cellEditor` for editing.
+ *
+ * Cell value: number or string like `"25"` / `"25%"`, or `{ value, cellMetadata? }`.
+ *
+ * Styling via `cellRendererParams`: `badgeVariant`, `badgeColor`, `badgeShape`, `progressVariant`.
+ */
+export declare const PercentProgressDisplayRenderer: {
+    (props: PercentProgressDisplayRendererProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/components/data/ag-grid-react/cell-renderers/percent-progress-display-renderer.js

@@ -0,0 +1,62 @@
+import { jsx as o, jsxs as $ } from "react/jsx-runtime";
+import { Badge as j } from "../../../data-display/badge/badge.js";
+import { Progress as w } from "../../../primitives/progress/progress.js";
+import { cn as E } from "../../../../lib/utils.js";
+function F(e) {
+  return e && typeof e == "object" && "value" in e ? e.value : e;
+}
+function S(e) {
+  if (e == null || e === "") return null;
+  if (typeof e == "number") return isNaN(e) ? null : e;
+  const a = Number(String(e).replace(/%/g, "").trim());
+  return isNaN(a) ? null : a;
+}
+function _(e, a, n) {
+  return Math.min(n, Math.max(a, e));
+}
+const A = (e) => {
+  const { value: a, disabled: n, colDef: s, className: h, data: r } = e, l = e.min ?? 0, d = e.max ?? 100, m = e.fractionDigits ?? 0, N = e.badgeVariant ?? "subtle", x = e.badgeColor ?? "neutral", p = e.badgeShape ?? "circle", v = e.progressVariant ?? "default", u = a && typeof a == "object" && "cellMetadata" in a ? a.cellMetadata?._isDisabled : void 0, f = r && typeof r == "object" && "rowMetadata" in r ? r.rowMetadata?._isDisabled : void 0;
+  let t = !1;
+  if (!n) {
+    const V = s?._originalEditable;
+    s?.editable === !1 ? t = !1 : u === !1 ? t = !0 : u === !0 ? t = !1 : f === !1 ? t = !0 : f === !0 ? t = !1 : t = V === !0 || s?.editable === !0;
+  }
+  const y = F(a), g = S(y), i = g != null, c = i ? _(g, l, d) : l, D = d - l || 1, P = i ? (c - l) / D * 100 : 0, b = i ? m > 0 ? `${c.toFixed(m)}%` : `${Math.round(c)}%` : "--", M = `${s?.headerName?.trim() || "Progress"}: ${b}`;
+  return /* @__PURE__ */ o(
+    "div",
+    {
+      className: `w-full h-full flex items-center ag-cell-inner-padding ${h ?? ""} ${n ? "opacity-60 cursor-not-allowed" : t ? "in-ag-editable-cell-highlight" : ""}`,
+      children: /* @__PURE__ */ $("div", { className: "flex w-full min-w-0 items-center gap-2", children: [
+        /* @__PURE__ */ o("div", { className: "min-w-0 flex-1", children: /* @__PURE__ */ o(
+          w,
+          {
+            label: !1,
+            "aria-label": M,
+            variant: v,
+            value: P,
+            max: 100,
+            "aria-valuenow": i ? c : void 0,
+            "aria-valuemin": l,
+            "aria-valuemax": d,
+            className: "h-2.5"
+          }
+        ) }),
+        /* @__PURE__ */ o(
+          j,
+          {
+            variant: N,
+            color: x,
+            shape: p,
+            size: "sm",
+            className: E("shrink-0 tabular-nums leading-none", !i && "text-content-empty"),
+            children: b
+          }
+        )
+      ] })
+    }
+  );
+};
+A.displayName = "PercentProgressDisplayRenderer";
+export {
+  A as PercentProgressDisplayRenderer
+};

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

@@ -0,0 +1,31 @@
+import { jsx as n, jsxs as m } from "react/jsx-runtime";
+import { ChevronRight as g } from "impact-nova-icons";
+const h = (u) => {
+  const { value: e, options: p = [], placeholder: b = "Select...", disabled: o, colDef: i, data: l } = u, c = e && typeof e == "object" && "cellMetadata" in e ? e.cellMetadata?._isDisabled : void 0, r = l && typeof l == "object" && "rowMetadata" in l ? l.rowMetadata?._isDisabled : void 0;
+  let t = !1;
+  if (!o) {
+    const s = i?._originalEditable;
+    i?.editable === !1 ? t = !1 : c === !1 ? t = !0 : c === !0 ? t = !1 : r === !1 ? t = !0 : r === !0 ? t = !1 : t = s === !0 || i?.editable === !0;
+  }
+  const a = e && typeof e == "object" && "value" in e ? e.value : e, d = p.find((s) => s.value === String(a ?? ""))?.label ?? (a != null && a !== "" ? String(a) : ""), f = !d;
+  return /* @__PURE__ */ n(
+    "div",
+    {
+      className: `w-full h-full flex items-center ag-cell-inner-padding ${o ? "opacity-60 cursor-not-allowed" : t ? "in-ag-editable-cell-highlight" : ""}`,
+      children: /* @__PURE__ */ m(
+        "div",
+        {
+          className: `flex w-full items-center justify-between rounded-[8px] px-1.5 h-7 ${t ? "bg-canvas-elevated cursor-pointer" : "bg-inherit"}`,
+          children: [
+            /* @__PURE__ */ n("span", { className: `truncate text-sm font-medium text-content ${f ? "text-content-empty" : ""}`, children: f ? b : d }),
+            t && /* @__PURE__ */ n(g, { className: "h-3.5 w-3.5 shrink-0 rotate-90 text-content-icon" })
+          ]
+        }
+      )
+    }
+  );
+};
+h.displayName = "SelectDisplayRenderer";
+export {
+  h as SelectDisplayRenderer
+};

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

@@ -0,0 +1,31 @@
+import { default as React } from 'react';
+import { ICellRendererParams, ColDef, GridApi, Column } from 'ag-grid-enterprise';
+import { SplitConfig, SubCellComponentProps, ValueFormatter, SplitCellValue } from './types';
+export interface CommonParams {
+    cellRenderer?: string | React.ComponentType<SubCellComponentProps>;
+    cellEditor?: string | React.ComponentType<SubCellComponentProps>;
+    cellRendererParams?: Record<string, unknown>;
+    cellEditorParams?: Record<string, unknown>;
+}
+export interface metaData {
+    [key: string]: "string";
+}
+export interface SplitCellRendererProps extends ICellRendererParams {
+    splits: SplitConfig[];
+    commonParams?: CommonParams;
+    metaData: metaData;
+    value: SplitCellRendererValue;
+    api: GridApi;
+    column: Column;
+    colDef: ColDef;
+    context: {
+        frameworkComponents?: Record<string, React.ComponentType<SubCellComponentProps>>;
+    };
+    /** Column-level value formatter (lowest priority: cell > row > split > column) */
+    valueFormatter?: ValueFormatter;
+}
+export type SplitCellRendererValue = SplitCellValue;
+export declare const SplitCellRenderer: {
+    (props: SplitCellRendererProps): import("react/jsx-runtime").JSX.Element | null;
+    displayName: string;
+};