impact-nova 0.1.0

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

@@ -0,0 +1,35 @@
+import { ICellRendererParams } from 'ag-grid-community';
+export interface SwitchDisplayRendererProps extends ICellRendererParams {
+    /** Label shown to the left of the switch */
+    leftLabel?: string;
+    /** Label shown to the right of the switch */
+    rightLabel?: string;
+    /** Whether the switch is disabled */
+    disabled?: boolean;
+}
+/**
+ * SwitchDisplayRenderer - Lightweight styled div that looks like a toggle switch.
+ *
+ * Like CheckboxDisplayRenderer, this toggles the boolean value directly on click
+ * via `node.setDataValue()`. No separate editor component is needed.
+ *
+ * Zero React state: the on/off state is derived from `props.value`.
+ *
+ * The switch visual matches impact-nova's Switch component styling
+ * (16px height, 24px width, rounded-full) but is rendered as pure CSS divs
+ * to avoid mounting a Radix primitive for every cell.
+ *
+ * Usage in colDef:
+ * ```ts
+ * {
+ *   field: 'isEnabled',
+ *   cellRenderer: SwitchDisplayRenderer,
+ *   editable: false,
+ *   cellRendererParams: { leftLabel: 'Off', rightLabel: 'On' },
+ * }
+ * ```
+ */
+export declare const SwitchDisplayRenderer: {
+    (props: SwitchDisplayRendererProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

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

@@ -0,0 +1,38 @@
+import { jsxs as b, jsx as t } from "react/jsx-runtime";
+import { useCallback as d } from "react";
+const p = (c) => {
+  const { value: u, node: i, column: l, leftLabel: o, rightLabel: s, disabled: e } = c, r = !!u, a = d(() => {
+    e || !l || i.setDataValue(l.getColId(), !r);
+  }, [e, l, i, r]), h = d(
+    (n) => {
+      e || (n.key === " " || n.key === "Enter") && (n.preventDefault(), a());
+    },
+    [e, a]
+  );
+  return /* @__PURE__ */ b("div", { className: `flex items-center justify-center h-full w-full gap-2 ag-cell-inner-padding ${e ? "opacity-60 cursor-not-allowed" : !e ? "ag-editable-cell-highlight" : ""}`, children: [
+    o && /* @__PURE__ */ t("span", { className: "text-xs text-muted-foreground", children: o }),
+    /* @__PURE__ */ t(
+      "div",
+      {
+        onClick: a,
+        onKeyDown: h,
+        role: "switch",
+        "aria-checked": r,
+        "aria-disabled": e,
+        tabIndex: e ? -1 : 0,
+        className: `inline-flex h-4 w-6 shrink-0 items-center rounded-full border transition-colors ${e ? "cursor-not-allowed opacity-50" : "cursor-pointer"} ${r ? "bg-[#eceefd] border-accordion-bg" : "bg-white border-light-blue"}`,
+        children: /* @__PURE__ */ t(
+          "div",
+          {
+            className: `pointer-events-none block h-[10px] w-[10px] rounded-full shadow-lg transition-transform ${r ? "translate-x-[10px] bg-primary" : "translate-x-[2px] bg-tertiary-border"}`
+          }
+        )
+      }
+    ),
+    s && /* @__PURE__ */ t("span", { className: "text-xs text-muted-foreground", children: s })
+  ] });
+};
+p.displayName = "SwitchDisplayRenderer";
+export {
+  p as SwitchDisplayRenderer
+};

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

@@ -0,0 +1,34 @@
+import { ICellRendererParams } from 'ag-grid-community';
+export interface TextAreaDisplayRendererProps extends ICellRendererParams {
+    /** Placeholder text shown when value is empty */
+    placeholder?: string;
+    /** Whether the field is disabled */
+    disabled?: boolean;
+    /** Maximum lines to show before truncating (default: 2) */
+    maxLines?: number;
+}
+/**
+ * TextAreaDisplayRenderer - Lightweight styled div showing truncated multi-line text.
+ *
+ * This is the DISPLAY component. It renders no `<textarea>` element and holds
+ * zero React state. Shows the text value with line-clamp truncation.
+ * When clicked, AG Grid activates the paired `TextAreaCellEditor` as a popup.
+ *
+ * Usage in colDef:
+ * ```ts
+ * {
+ *   field: 'description',
+ *   cellRenderer: TextAreaDisplayRenderer,
+ *   cellEditor: TextAreaCellEditor,
+ *   cellEditorPopup: true,
+ *   editable: true,
+ *   singleClickEdit: true,
+ *   cellRendererParams: { placeholder: 'Enter description...', maxLines: 2 },
+ *   cellEditorParams: { rows: 4, maxLength: 500, placeholder: 'Enter description...' },
+ * }
+ * ```
+ */
+export declare const TextAreaDisplayRenderer: {
+    (props: TextAreaDisplayRendererProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

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

@@ -0,0 +1,32 @@
+import { jsx as l } from "react/jsx-runtime";
+const m = (r) => {
+  const { valueFormatted: s, value: t, placeholder: d, disabled: i, maxLines: n = 2, colDef: o } = r, c = !i && o?.editable === !0, e = s ?? (t != null ? String(t) : ""), a = e === "" || e == null;
+  return /* @__PURE__ */ l(
+    "div",
+    {
+      className: `w-full h-full flex items-center ag-cell-inner-padding ${i ? "opacity-60 cursor-not-allowed" : c ? "ag-editable-cell-highlight" : ""}`,
+      children: /* @__PURE__ */ l(
+        "div",
+        {
+          className: "flex w-full items-center rounded-[8px] bg-white px-1.5 h-7 cursor-text",
+          children: /* @__PURE__ */ l(
+            "span",
+            {
+              className: `w-full text-sm font-medium text-[#1f2b4d] overflow-hidden ${a ? "text-[#dfe2e7]" : ""}`,
+              style: {
+                display: "-webkit-box",
+                WebkitLineClamp: n,
+                WebkitBoxOrient: "vertical"
+              },
+              children: a ? d ?? "" : e
+            }
+          )
+        }
+      )
+    }
+  );
+};
+m.displayName = "TextAreaDisplayRenderer";
+export {
+  m as TextAreaDisplayRenderer
+};

package/dist/components/ui/ag-grid-react/cell-renderers/types.d.ts

@@ -0,0 +1,129 @@
+import { ReactNode } from 'react';
+import { IRowNode, ColDef, GridApi, Column } from 'ag-grid-community';
+/**
+ * Badge variant/color mapping types used across badge-related renderers.
+ */
+export type BadgeVariant = 'solid' | 'outline' | 'subtle';
+export type BadgeColor = 'primary' | 'success' | 'warning' | 'destructive' | 'neutral';
+/**
+ * Maps legacy variant names (from backend/config) to impact-nova Badge variants.
+ */
+export declare const mapBadgeVariant: (v: string | undefined) => BadgeVariant;
+/**
+ * Maps legacy color names (from backend/config) to impact-nova Badge colors.
+ */
+export declare const mapBadgeColor: (c: string | undefined) => BadgeColor;
+/**
+ * Resolves a value from either a static prop or a field in row data.
+ * Used by renderers that support both static and dynamic (field-driven) configuration.
+ */
+export declare const getFieldValue: <T>(fieldName: string | undefined, staticValue: T | undefined, rowData: Record<string, unknown> | null | undefined) => T | undefined;
+/**
+ * Validation condition for dynamic behavior
+ */
+export interface ValidationCondition {
+    field: string;
+    condition: '>' | '<' | '>=' | '<=' | '==' | '!=' | 'contains';
+    value: any;
+}
+/**
+ * Validation rules for disabling/enabling elements
+ */
+export interface ValidationRules {
+    disabled?: {
+        operator: 'AND' | 'OR';
+        conditions: ValidationCondition[];
+    };
+}
+/**
+ * Evaluates validation rules against row data
+ */
+export declare const evaluateValidationRules: (rules: ValidationRules | undefined, rowData: Record<string, unknown> | null | undefined) => boolean;
+export interface SelectOption {
+    label: string;
+    value: string;
+    isDisabled?: boolean;
+}
+export interface ActionButton {
+    label: string;
+    onClick: (data: Record<string, unknown>) => void;
+    variant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost' | 'link';
+    size?: 'default' | 'sm' | 'lg' | 'icon';
+    icon?: ReactNode;
+    iconPlacement?: 'left' | 'right';
+    className?: string;
+    disabled?: boolean;
+}
+export interface RightSideIcon {
+    icon?: string | ReactNode;
+    iconField?: string;
+    tooltip?: string;
+    tooltipField?: string;
+    tooltipSide?: 'top' | 'bottom' | 'left' | 'right';
+    backgroundColor?: string;
+    backgroundColorField?: string;
+    color?: string;
+    colorField?: string;
+    showOnHover?: boolean;
+    onClick?: (params: {
+        rowId: string;
+        field: string;
+        rowData: Record<string, unknown>;
+    }) => void | Promise<void>;
+}
+export interface RightSideBadge {
+    label?: string;
+    labelField?: string;
+    color?: string;
+    colorField?: string;
+    variant?: string;
+    variantField?: string;
+    onClick?: (params: {
+        rowId: string;
+        field: string;
+        rowData: Record<string, unknown>;
+    }) => void | Promise<void>;
+}
+export interface RightSideContentItem {
+    type: 'icon' | 'badge' | 'dynamic';
+    icon?: RightSideIcon;
+    badge?: RightSideBadge;
+    dynamic?: ReactNode | ((rowData: Record<string, unknown>) => ReactNode);
+}
+export interface RightSideContent {
+    items: RightSideContentItem[];
+}
+/**
+ * Props passed to components rendered within a SplitCellRenderer or SplitCellEditor.
+ * These are "sub-cell" components that receive a subset of standard AG Grid params.
+ */
+export interface SubCellComponentProps {
+    value: unknown;
+    valueFormatted?: string;
+    data: unknown;
+    node?: IRowNode;
+    colDef?: ColDef;
+    api?: GridApi;
+    column?: Column;
+    context?: unknown;
+    onValueChange?: (value: unknown) => void;
+    suppressAutoFocus?: boolean;
+    stopEditing?: (suppressNavigateAfterEdit?: boolean) => void;
+}
+export interface SplitConfig {
+    field: string;
+    headerName?: string;
+    type?: string;
+    editable?: boolean;
+    cellRenderer?: string | React.ComponentType<SubCellComponentProps>;
+    cellRendererParams?: Record<string, unknown>;
+    cellEditor?: string | React.ComponentType<SubCellComponentProps>;
+    cellEditorParams?: Record<string, unknown>;
+    valueFormatter?: string | {
+        type: string;
+        [key: string]: any;
+    } | ((params: {
+        value: unknown;
+        data: unknown;
+    }) => string | React.ReactNode);
+}

package/dist/components/ui/ag-grid-react/cell-renderers/types.js

@@ -0,0 +1,74 @@
+const i = (r) => {
+  switch (r) {
+    case "filled":
+      return "solid";
+    case "stroke":
+      return "outline";
+    case "subtle":
+      return "subtle";
+    case "solid":
+      return "solid";
+    case "outline":
+      return "outline";
+    default:
+      return "solid";
+  }
+}, l = (r) => {
+  switch (r) {
+    case "default":
+      return "primary";
+    case "info":
+      return "primary";
+    case "success":
+      return "success";
+    case "warning":
+      return "warning";
+    case "error":
+      return "destructive";
+    case "primary":
+      return "primary";
+    case "destructive":
+      return "destructive";
+    case "neutral":
+      return "neutral";
+    default:
+      return "primary";
+  }
+}, c = (r, n, u) => {
+  if (r && u && r in u) {
+    const s = u[r];
+    return s != null && s !== "" ? s : void 0;
+  }
+  return n;
+}, o = (r, n) => {
+  if (!r?.disabled || !n) return !1;
+  const { operator: u, conditions: s } = r.disabled, a = s.map((e) => {
+    const t = n[e.field];
+    if (t == null) return !1;
+    switch (e.condition) {
+      case ">":
+        return Number(t) > Number(e.value);
+      case "<":
+        return Number(t) < Number(e.value);
+      case ">=":
+        return Number(t) >= Number(e.value);
+      case "<=":
+        return Number(t) <= Number(e.value);
+      case "==":
+        return t == e.value;
+      case "!=":
+        return t != e.value;
+      case "contains":
+        return String(t).includes(String(e.value));
+      default:
+        return !1;
+    }
+  });
+  return u === "AND" ? a.every((e) => e === !0) : u === "OR" ? a.some((e) => e === !0) : !1;
+};
+export {
+  o as evaluateValidationRules,
+  c as getFieldValue,
+  l as mapBadgeColor,
+  i as mapBadgeVariant
+};

package/dist/components/ui/ag-grid-react/headers/advanced-filter/advanced-filter-dialog.d.ts

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+import { AdvancedFilterModel } from '../../../types/ag-grid.types';
+import { GridApi } from 'ag-grid-community';
+interface AdvancedFilterDialogProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onApply: (model: AdvancedFilterModel | null) => void;
+    columnId: string;
+    columnLabel: string;
+    columnType: 'text' | 'number' | 'date' | 'select' | 'multi';
+    selectOptions?: Array<{
+        label: string;
+        value: string;
+    }>;
+    isMultiSelect?: boolean;
+    initialModel?: AdvancedFilterModel | null;
+    api?: GridApi;
+}
+/**
+ * AdvancedFilterDialog - Uses ColumnFilterSection for each column.
+ * Per-column logic stored as a map.
+ */
+export declare const AdvancedFilterDialog: React.FC<AdvancedFilterDialogProps>;
+export default AdvancedFilterDialog;

package/dist/components/ui/ag-grid-react/headers/advanced-filter/advanced-filter-dialog.js

@@ -0,0 +1,223 @@
+import { jsxs as f, jsx as r, Fragment as Q } from "react/jsx-runtime";
+import { useState as R } from "react";
+import { Dialog as U, DialogContent as W, DialogHeader as X, DialogTitle as Y, DialogClose as Z, DialogBody as _, DialogFooter as I } from "../../../dialog.js";
+import { Button as p } from "../../../button.js";
+import { ButtonGroup as ee } from "../../../button-group.js";
+import { Cross as te } from "../../../../../icons/index.js";
+import { ColumnFilterSection as q } from "./column-filter-section.js";
+import { createEmptyRule as F } from "../utils/filter-utils.js";
+const z = (N) => {
+  const c = {};
+  return N.forEach((m) => {
+    m.columnId && (c[m.columnId] || (c[m.columnId] = []), c[m.columnId].push(m));
+  }), c;
+}, ce = ({
+  isOpen: N,
+  onClose: c,
+  onApply: m,
+  columnId: s,
+  columnLabel: B,
+  columnType: C,
+  selectOptions: A,
+  isMultiSelect: P,
+  initialModel: j,
+  api: d
+  // Add api to props
+}) => {
+  const T = () => (j?.rules || []).filter((e) => !("logic" in e)), [y, $] = R("column"), [x, S] = R(() => {
+    const e = {}, n = T(), t = z(n);
+    return Object.keys(t).forEach((a) => {
+      e[a] = j?.logic || "OR";
+    }), e[s] || (e[s] = "OR"), e;
+  }), [h, O] = R(() => {
+    const e = T();
+    if (d) {
+      const t = d.getFilterModel();
+      t && Object.keys(t).forEach((i) => {
+        if (!e.some((l) => l.columnId === i)) {
+          const l = t[i];
+          let o = null;
+          if (l.filterType === "text")
+            o = {
+              id: Math.random().toString(36).substr(2, 9),
+              columnId: i,
+              columnType: "text",
+              operator: l.type === "contains" ? "contains" : "equals",
+              value: l.filter
+            };
+          else if (l.filterType === "number")
+            o = {
+              id: Math.random().toString(36).substr(2, 9),
+              columnId: i,
+              columnType: "number",
+              operator: l.type === "equals" ? "equals" : l.type || "equals",
+              value: String(l.filter)
+            };
+          else if (l.filterType === "set")
+            o = {
+              id: Math.random().toString(36).substr(2, 9),
+              columnId: i,
+              columnType: "select",
+              operator: "equals",
+              value: l.values
+            };
+          else if (l.filterType === "multi") {
+            const u = l.filterModels?.find((b) => b && b.filterType === "set");
+            u && (o = {
+              id: Math.random().toString(36).substr(2, 9),
+              columnId: i,
+              columnType: "multi",
+              // or select?
+              operator: "equals",
+              value: u.values
+            });
+          }
+          o && e.push(o);
+        }
+      });
+    }
+    return e.some((t) => t.columnId === s) || e.push(F(s, C)), e;
+  }), [v] = R(() => ({
+    allRules: h,
+    // Use the computed rules (potentially synced)
+    columnLogic: { ...x }
+  })), G = JSON.stringify({ allRules: h, columnLogic: x }) !== JSON.stringify(v), k = (e) => h.filter((n) => n.columnId === e), D = (e, n) => {
+    O((t) => {
+      const a = /* @__PURE__ */ new Set(), i = [];
+      t.forEach((o) => {
+        a.has(o.columnId) || (a.add(o.columnId), i.push(o.columnId));
+      }), a.has(e) || i.push(e);
+      const l = [];
+      return i.forEach((o) => {
+        o === e ? l.push(...n) : l.push(...t.filter((u) => u.columnId === o));
+      }), l;
+    });
+  }, L = (e) => x[e] || "OR", M = (e, n) => {
+    S((t) => ({ ...t, [e]: n }));
+  }, J = () => {
+    y === "column" ? (D(s, [F(s, C)]), M(s, "OR")) : (O([F(s, C)]), S({ [s]: "OR" }));
+  }, H = () => {
+    O(v.allRules.length > 0 ? v.allRules : [F(s, C)]), S(v.columnLogic);
+  }, V = () => {
+    const e = h.filter((n) => n.operator === "empty" || n.operator === "notEmpty" ? !!n.columnId : n.columnId && n.value !== "" && n.value !== null);
+    if (e.length === 0)
+      m(null);
+    else {
+      const n = e[0].columnId;
+      m({ logic: L(n), rules: e });
+    }
+    c();
+  }, K = z(h), w = Object.keys(K), E = (e, n) => {
+    if (!d) return n;
+    const t = d.getColumn(e);
+    if (!t) return n;
+    const a = t.getColDef(), i = [];
+    let l = t.getParent();
+    for (; l; ) {
+      const u = l.getColGroupDef();
+      u && u.headerName && i.unshift(u.headerName), l = l.getParent();
+    }
+    const o = a?.headerName || e;
+    return i.push(o), i.join(" > ");
+  };
+  return /* @__PURE__ */ f(U, { open: N, onOpenChange: c, children: [
+    (console.log("[AdvancedFilterDialog] Current State:", {
+      mode: y,
+      allRules: h,
+      columnLogic: x,
+      activeColumns: w
+    }), null),
+    /* @__PURE__ */ f(W, { className: "w-[550px] max-w-[95vw] p-0", hideClose: !0, children: [
+      /* @__PURE__ */ f(X, { className: "flex flex-row items-center gap-4 px-4 py-2", children: [
+        /* @__PURE__ */ r(Y, { children: "Advanced Filter" }),
+        /* @__PURE__ */ r("div", { className: "flex-1 flex  items-center justify-end", children: /* @__PURE__ */ f(
+          ee,
+          {
+            className: "",
+            value: y,
+            onValueChange: (e) => $(e),
+            children: [
+              /* @__PURE__ */ r(p, { value: "column", size: "md", children: "Current Column" }),
+              /* @__PURE__ */ r(p, { value: "global", size: "md", children: "All Filters" })
+            ]
+          }
+        ) }),
+        /* @__PURE__ */ r(Z, { asChild: !0, children: /* @__PURE__ */ r(p, { variant: "ghost", size: "icon", className: "h-8 w-8 p-0 text-[#60697D] hover:text-[#3649C6]", onClick: c, "aria-label": "Close", children: /* @__PURE__ */ r(te, { size: 14 }) }) })
+      ] }),
+      /* @__PURE__ */ r(_, { className: "px-0 py-4 min-h-[300px] max-h-[400px] overflow-y-auto", children: /* @__PURE__ */ r("div", { className: "flex flex-col gap-6 w-full px-4", children: y === "column" ? (
+        // Column Mode: Single column section
+        /* @__PURE__ */ r(
+          q,
+          {
+            columnId: s,
+            columnLabel: E(s, B),
+            columnType: C,
+            selectOptions: A,
+            isMultiSelect: A ? !!P : !0,
+            rules: k(s),
+            logic: L(s),
+            onLogicChange: (e) => M(s, e),
+            onRulesChange: (e) => D(s, e)
+          }
+        )
+      ) : (
+        // Global Mode: All columns with filters
+        /* @__PURE__ */ r(Q, { children: w.length === 0 ? /* @__PURE__ */ r("div", { className: "text-center py-8 text-slate-400", children: "No filters applied. Open a column to add filters." }) : w.map((e, n) => {
+          let t = null;
+          if (d) {
+            const g = d.getColumn(e);
+            g && (t = g.getColDef());
+          }
+          const a = t?.headerComponentParams, i = t?.headerName || e, l = E(e, i), o = t?.filter === "agNumberColumnFilter" ? "number" : t?.filter === "agDateColumnFilter" ? "date" : t?.filter === "agMultiColumnFilter" ? "multi" : t?.filter === "agSetColumnFilter" || a?.selectOptions ? "select" : "text";
+          console.log(`[AdvancedFilterDialog] Column: ${e}, Type: ${o}, Filter: ${t?.filter}`);
+          const u = a?.selectOptions, b = a?.isMultiSelect;
+          return /* @__PURE__ */ f("div", { children: [
+            n > 0 && /* @__PURE__ */ r("hr", { className: "border-slate-200 mb-6" }),
+            /* @__PURE__ */ r(
+              q,
+              {
+                columnId: e,
+                columnLabel: l,
+                columnType: o,
+                selectOptions: u,
+                isMultiSelect: b,
+                rules: k(e),
+                logic: L(e),
+                onLogicChange: (g) => M(e, g),
+                onRulesChange: (g) => D(e, g),
+                canDeleteLastRule: !0,
+                onDeleteColumnFilter: () => D(e, [])
+              }
+            )
+          ] }, e);
+        }) })
+      ) }) }),
+      /* @__PURE__ */ f(I, { className: "flex justify-between", children: [
+        /* @__PURE__ */ r(
+          p,
+          {
+            onClick: J,
+            variant: "secondary",
+            children: "Clear all"
+          }
+        ),
+        /* @__PURE__ */ f("div", { className: "flex gap-3", children: [
+          /* @__PURE__ */ r(
+            p,
+            {
+              onClick: H,
+              variant: "outline",
+              disabled: !G,
+              children: "Discard"
+            }
+          ),
+          /* @__PURE__ */ r(p, { onClick: V, variant: "default", children: "Apply" })
+        ] })
+      ] })
+    ] })
+  ] });
+};
+export {
+  ce as AdvancedFilterDialog,
+  ce as default
+};

package/dist/components/ui/ag-grid-react/headers/advanced-filter/column-filter-section.d.ts

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+import { AdvancedFilterRule } from '../../../types/ag-grid.types';
+export interface ColumnFilterSectionProps {
+    columnId: string;
+    columnLabel: string;
+    columnType: 'text' | 'number' | 'date' | 'select' | 'multi';
+    selectOptions?: Array<{
+        label: string;
+        value: string;
+    }>;
+    isMultiSelect?: boolean;
+    rules: AdvancedFilterRule[];
+    logic: 'AND' | 'OR';
+    onLogicChange: (logic: 'AND' | 'OR') => void;
+    onRulesChange: (rules: AdvancedFilterRule[]) => void;
+    canDeleteLastRule?: boolean;
+    onDeleteColumnFilter?: () => void;
+}
+/**
+ * ColumnFilterSection - Self-contained filter UI for one column.
+ * Manages its own logic (AND/OR) independently.
+ */
+export declare const ColumnFilterSection: React.FC<ColumnFilterSectionProps>;
+export default ColumnFilterSection;