impact-nova 2.0.8 → 2.1.0-alpha.1

package/dist/components/data/nested-list/nested-list.js

@@ -0,0 +1,391 @@
+import { jsx as L, jsxs as oe } from "react/jsx-runtime";
+import K, { useMemo as T, useCallback as w } from "react";
+import { SortableItem as qe } from "./components/SortableItem.js";
+import { SelectionMode as y } from "./nested-list.types.js";
+import { useNestedListDragDrop as Ke } from "./hooks/useNestedListDragDrop.js";
+import { useNestedListSelectAll as Qe } from "./hooks/useNestedListSelectAll.js";
+import { useNestedListState as Xe } from "./hooks/useNestedListState.js";
+import { useNestedListHandlers as Ye } from "./hooks/useNestedListHandlers.js";
+import { NestedListHeader as Ze } from "./components/NestedListHeader.js";
+import { NestedListCategoryFilters as $e } from "./components/NestedListCategoryFilters.js";
+import { NestedListContent as Me } from "./components/NestedListContent.js";
+import { NestedListApplyDiscardButtons as Ge } from "./components/NestedListApplyDiscardButtons.js";
+import { cn as et } from "../../../lib/utils.js";
+import { useImpactNovaI18n as tt } from "../../../i18n/use-impact-nova-i18n.js";
+const de = (h, t) => {
+  if (!t || typeof t != "string") return h;
+  const c = t.toLowerCase(), o = [];
+  return h.forEach((r) => {
+    const i = r.label.toLowerCase().includes(c), l = r.children ? de(r.children, t) : void 0;
+    (i || l && l.length > 0) && o.push({
+      ...r,
+      children: l || r.children
+    });
+  }), o;
+}, ie = (h) => h.map((t) => {
+  if (t.children && t.children.length > 0) {
+    const c = ie(t.children), o = c.every((r) => r.checked);
+    return {
+      ...t,
+      checked: o,
+      children: c
+    };
+  }
+  return t;
+}), st = (h, t) => {
+  const c = /* @__PURE__ */ new Set(), o = (r) => {
+    r.forEach((i) => {
+      const l = t ? t(i) : i.category;
+      l && c.add(l), i.children && o(i.children);
+    });
+  };
+  return o(h), Array.from(c).sort();
+}, ae = (h, t, c) => {
+  if (t.size === 0) return h;
+  const o = [];
+  return h.forEach((r) => {
+    const i = c ? c(r) : r.category, l = i && t.has(i), m = r.children ? ae(r.children, t, c) : void 0;
+    (l || m && m.length > 0) && o.push({
+      ...r,
+      children: m
+    });
+  }), o;
+}, he = (h, t, c, o = 0, r = 0) => {
+  const i = [];
+  return h.forEach((l) => {
+    if (i.push({
+      item: l,
+      level: o,
+      indentLevel: l.category === "structure" ? 0 : r
+    }), !t[l.id] && l.children && l.children.length > 0 && l.id !== c) {
+      const U = l.category === "structure" ? 0 : r + 1;
+      i.push(
+        ...he(
+          l.children,
+          t,
+          c,
+          o + 1,
+          U
+        )
+      );
+    }
+  }), i;
+}, St = ({
+  items: h,
+  onChange: t,
+  onSubmit: c,
+  onCancel: o,
+  onItemToggle: r,
+  onDragEnd: i,
+  renderLabelExtras: l,
+  renderActions: m,
+  enableSearch: U = !0,
+  enableDragDrop: _ = !0,
+  enableSelectAll: ue = !0,
+  enableGroupBy: k = !1,
+  getCategory: C,
+  searchPlaceholder: fe,
+  className: pe = "",
+  groupLabel: me,
+  enableApplyDiscard: p = !1,
+  enableCollapse: Q = !0,
+  enableGlobalCollapse: Ne = !0,
+  submitButtonLabel: Se,
+  cancelButtonLabel: Ie,
+  selectionMode: v = y.CASCADE_DOWN,
+  initialCollapsedItems: Ce,
+  onCollapseChange: X,
+  canDrag: A
+}) => {
+  const { t: P } = tt(), ve = fe ?? P("nestedList.searchPlaceholder"), ge = Se ?? P("nestedList.apply"), Le = Ie ?? P("nestedList.reset"), {
+    items: u,
+    setItems: g,
+    savedItems: b,
+    setSavedItems: Y,
+    isUserChangeRef: x,
+    searchText: z,
+    setSearchText: ke,
+    collapsedItems: N,
+    setCollapsedItems: Ee,
+    isListCollapsed: B,
+    setIsListCollapsed: De,
+    activeId: S,
+    setActiveId: H,
+    setOverId: W,
+    selectedCategories: O,
+    setSelectedCategories: Te,
+    itemsToBlink: Z,
+    setItemsToBlink: j,
+    // Normalized state helpers (for optimized operations)
+    isNormalized: we,
+    normalizedState: Ae,
+    batchUpdateItems: Pe
+  } = Xe({
+    initialItems: h,
+    enableApplyDiscard: p,
+    // Enable normalized state for large datasets (can be made configurable via props)
+    enableNormalizedState: h.length > 1e3,
+    initialCollapsedItems: Ce
+  });
+  K.useEffect(() => {
+    X?.(N);
+  }, [N, X]);
+  const [R, $] = K.useState(0), [V, be] = K.useState(0), {
+    sensors: xe,
+    handleDragEnd: ze,
+    isValidDrop: M
+  } = Ke({
+    items: u,
+    onDragEnd: i,
+    collapsedItems: N,
+    canDrag: A
+  }), Be = T(
+    () => k ? st(u, C) : [],
+    [u, k, C]
+  ), I = T(() => {
+    let e = u;
+    return k && O.size > 0 && (e = ae(e, O, C)), z && (e = de(e, z)), e;
+  }, [u, z, k, O, C]), Oe = T(
+    () => he(I, N, S),
+    [I, N, S]
+  ), { allChecked: E, someChecked: Re } = T(() => {
+    let e = !0, s = !1;
+    const n = (f) => {
+      for (const a of f)
+        if (a.children && a.children.length > 0 ? n(a.children) : a.checked ? s = !0 : e = !1, s && !e) return;
+    };
+    return n(I), { allChecked: e && s, someChecked: s };
+  }, [I]), Ve = Re && !E, F = (e, s) => {
+    for (const n of e) {
+      if (n.id === s) return n;
+      if (n.children) {
+        const f = F(n.children, s);
+        if (f) return f;
+      }
+    }
+    return null;
+  }, ye = w(
+    (e, s) => {
+      if (v === y.INDEPENDENT)
+        return e;
+      const n = (a, d) => a.id === d ? !0 : a.children ? a.children.some(
+        (D) => n(D, d)
+      ) : !1, f = (a) => a.map((d) => {
+        if (d.id === s)
+          return d;
+        if (d.children && n(d, s)) {
+          const D = f(d.children);
+          let J;
+          return v === y.CASCADE_UP_DOWN ? J = D.some((q) => q.checked) : J = D.every((q) => q.checked), {
+            ...d,
+            checked: J,
+            children: D
+          };
+        }
+        return d;
+      });
+      return f(e);
+    },
+    [v]
+  ), G = (e) => {
+    const s = [];
+    return e.forEach((n) => {
+      n.children && n.children.length > 0 && (s.push(n.id), s.push(...G(n.children)));
+    }), s;
+  }, {
+    handleToggle: ee,
+    handleToggleCollapse: te,
+    handleCollapseAll: Ue,
+    handleToggleCategory: _e
+  } = Ye({
+    setItems: g,
+    findItemById: F,
+    updateParentsUpward: ye,
+    onChange: (e) => {
+      $((s) => s + 1), t(e);
+    },
+    onItemToggle: r,
+    getCategory: C,
+    setCollapsedItems: Ee,
+    setIsListCollapsed: De,
+    setSelectedCategories: Te,
+    isUserChangeRef: x,
+    selectionMode: v,
+    // Pass normalized state helpers for optimized operations
+    isNormalized: we,
+    normalizedState: Ae,
+    batchUpdateItems: Pe
+  }), {
+    collectVisibleItemIds: se,
+    findItemsNotSelected: re,
+    collectVisibleItemsForCallback: ne,
+    updateVisibleItems: le
+  } = Qe({
+    findItemById: F,
+    getCategory: C
+  }), He = w(() => {
+    x.current = !0, g((e) => {
+      const s = se(I), n = re(
+        I,
+        e,
+        s
+      );
+      if (n.size > 0) {
+        const d = new Set(n);
+        j(d), setTimeout(() => j(/* @__PURE__ */ new Set()), 600);
+      }
+      const f = le(
+        e,
+        s,
+        !E
+      ), a = v === y.INDEPENDENT ? f : ie(f);
+      if (t(a), r) {
+        const d = ne(
+          e,
+          s,
+          !E
+        );
+        r(d);
+      }
+      return a;
+    });
+  }, [
+    E,
+    t,
+    r,
+    I,
+    se,
+    re,
+    ne,
+    le,
+    x,
+    g,
+    j,
+    v
+  ]), We = w(
+    (e, s, n) => {
+      const f = S ? M(S, e.id) : !1, a = Z.has(e.id), d = A ? !A(e, s) : e.isDragDisabled ?? !1;
+      return /* @__PURE__ */ L(
+        qe,
+        {
+          item: e,
+          level: s,
+          indentLevel: n,
+          isCollapsed: N[e.id] || !1,
+          onToggle: ee,
+          onToggleCollapse: te,
+          isAnyDragging: S !== null,
+          isValidDrop: f,
+          enableDragDrop: _,
+          enableCollapse: Q,
+          shouldBlink: a,
+          isDragDisabled: d,
+          renderLabelExtras: l,
+          renderActions: m
+        },
+        e.id
+      );
+    },
+    [
+      N,
+      ee,
+      te,
+      S,
+      M,
+      _,
+      Z,
+      Q,
+      A,
+      l,
+      m
+    ]
+  ), je = G(u).length > 0, ce = T(() => p ? u.length > 1e3 ? R !== V : JSON.stringify(u) !== JSON.stringify(b) : !1, [p, u, b, R, V]), Fe = w(() => {
+    p && (Y(u), be(R), c?.(u));
+  }, [p, u, c, Y, R]), Je = w(() => {
+    p && (g(b), $(V), o?.());
+  }, [p, b, o, g, V]);
+  return /* @__PURE__ */ oe(
+    "div",
+    {
+      className: et("flex flex-col", pe),
+      "data-component": "nested-list",
+      "data-has-changes": ce ? "" : void 0,
+      "data-list-collapsed": B ? "" : void 0,
+      children: [
+        /* @__PURE__ */ oe("div", { className: "flex-shrink-0", children: [
+          /* @__PURE__ */ L(
+            Ze,
+            {
+              hasItemsWithChildren: je,
+              isListCollapsed: B,
+              onCollapseAll: Ue,
+              enableSearch: U,
+              enableSelectAll: ue,
+              groupLabel: me,
+              allChecked: E,
+              isIndeterminate: Ve,
+              onSelectAll: He,
+              searchText: z,
+              onSearchChange: (e) => {
+                ke(e.target.value);
+              },
+              searchPlaceholder: ve,
+              selectAllLabel: P("nestedList.selectAll"),
+              enableCollapse: Ne
+            }
+          ),
+          /* @__PURE__ */ L(
+            $e,
+            {
+              isListCollapsed: B,
+              enableGroupBy: k,
+              categories: Be,
+              selectedCategories: O,
+              onToggleCategory: _e
+            }
+          )
+        ] }),
+        /* @__PURE__ */ L("div", { className: "flex-1 min-h-0 overflow-hidden", children: /* @__PURE__ */ L(
+          Me,
+          {
+            isListCollapsed: B,
+            enableDragDrop: _,
+            sensors: xe,
+            items: Oe,
+            renderItem: We,
+            activeId: S,
+            onDragStart: (e) => {
+              H(e.active.id);
+            },
+            onDragOver: (e) => {
+              W(e.over?.id);
+            },
+            onDragEnd: (e) => {
+              H(null), W(null), x.current = !0, ze(e, (s) => {
+                const n = s(u);
+                g(n), t(n);
+              });
+            },
+            onDragCancel: () => {
+              H(null), W(null);
+            }
+          }
+        ) }),
+        /* @__PURE__ */ L(
+          Ge,
+          {
+            enableApplyDiscard: p,
+            hasChanges: ce,
+            onDiscard: Je,
+            onApply: Fe,
+            cancelButtonLabel: Le,
+            submitButtonLabel: ge
+          }
+        )
+      ]
+    }
+  );
+};
+export {
+  St as NestedList
+};

package/dist/components/data/nested-list/nested-list.types.d.ts

@@ -0,0 +1,55 @@
+import type * as React from "react";
+export interface NestedListItem {
+    id: string;
+    label: string;
+    checked: boolean;
+    indeterminate?: boolean;
+    disabled?: boolean;
+    children?: NestedListItem[];
+    category?: string;
+    isDragDisabled?: boolean;
+    data?: Record<string, unknown>;
+}
+export declare const SelectionMode: {
+    readonly INDEPENDENT: "independent";
+    readonly CASCADE_DOWN: "cascade-down";
+    readonly CASCADE_UP_DOWN: "cascade-up-down";
+};
+export type SelectionMode = (typeof SelectionMode)[keyof typeof SelectionMode];
+export interface NestedListProps {
+    items: NestedListItem[];
+    onChange: (items: NestedListItem[]) => void;
+    onSubmit?: (items: NestedListItem[]) => void;
+    onCancel?: () => void;
+    onItemToggle?: (changes: Array<{
+        itemId: string;
+        checked: boolean;
+        category?: string;
+    }>) => void;
+    onDragEnd?: (activeId: string, overId: string | null) => void;
+    renderLabelExtras?: (item: NestedListItem, context: {
+        isLeaf: boolean;
+        level: number;
+    }) => React.ReactNode;
+    renderActions?: (item: NestedListItem, context: {
+        isLeaf: boolean;
+        level: number;
+    }) => React.ReactNode;
+    enableSearch?: boolean;
+    enableDragDrop?: boolean;
+    enableSelectAll?: boolean;
+    enableGroupBy?: boolean;
+    enableApplyDiscard?: boolean;
+    enableCollapse?: boolean;
+    enableGlobalCollapse?: boolean;
+    selectionMode?: SelectionMode;
+    getCategory?: (item: NestedListItem) => string | undefined;
+    initialCollapsedItems?: Record<string, boolean>;
+    onCollapseChange?: (collapsedItems: Record<string, boolean>) => void;
+    canDrag?: (item: NestedListItem, level: number) => boolean;
+    searchPlaceholder?: string;
+    className?: string;
+    groupLabel?: string;
+    submitButtonLabel?: string;
+    cancelButtonLabel?: string;
+}

package/dist/components/data/nested-list/nested-list.types.js

@@ -0,0 +1,8 @@
+const e = {
+  INDEPENDENT: "independent",
+  CASCADE_DOWN: "cascade-down",
+  CASCADE_UP_DOWN: "cascade-up-down"
+};
+export {
+  e as SelectionMode
+};

package/dist/components/data-display/avatar/avatar.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import * as AvatarPrimitive from "@radix-ui/react-avatar";
+declare const Avatar: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React.RefAttributes<HTMLSpanElement>, "ref"> & import('class-variance-authority').VariantProps<(props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    shape?: "circle" | "square" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string> & React.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImage: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React.RefAttributes<HTMLImageElement>, "ref"> & React.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallback: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export { Avatar, AvatarImage, AvatarFallback };

package/dist/components/data-display/avatar/avatar.js

@@ -0,0 +1,36 @@
+import { jsx as c } from "react/jsx-runtime";
+import "react";
+import * as a from "@radix-ui/react-avatar";
+import { createComponent as s } from "../../../lib/primitives/create-component.js";
+import { wrapRadixPart as t } from "../../../lib/primitives/create-compound.js";
+import { cn as f } from "../../../lib/utils.js";
+import { avatarVariants as i } from "./avatar.variants.js";
+const g = s(
+  "Avatar",
+  ({ className: r, size: o, shape: e, ...m }, l) => /* @__PURE__ */ c(
+    a.Root,
+    {
+      ref: l,
+      className: f(i({ size: o, shape: e, className: r })),
+      "data-component": "avatar",
+      ...m
+    }
+  )
+), x = t(
+  "avatar",
+  "image",
+  "AvatarImage",
+  a.Image,
+  "aspect-square h-full w-full"
+), d = t(
+  "avatar",
+  "fallback",
+  "AvatarFallback",
+  a.Fallback,
+  "flex h-full w-full items-center justify-center bg-success text-success-foreground font-bold"
+);
+export {
+  g as Avatar,
+  d as AvatarFallback,
+  x as AvatarImage
+};

package/dist/components/data-display/avatar/avatar.types.d.ts

@@ -0,0 +1,7 @@
+import { VariantProps } from 'class-variance-authority';
+import { avatarVariants } from './avatar.variants';
+import type * as React from "react";
+import type * as AvatarPrimitive from "@radix-ui/react-avatar";
+export type AvatarProps = React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root> & VariantProps<typeof avatarVariants>;
+export type AvatarImageProps = React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Image>;
+export type AvatarFallbackProps = React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Fallback>;

package/dist/components/data-display/avatar/avatar.variants.d.ts

@@ -0,0 +1,4 @@
+export declare const avatarVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    shape?: "circle" | "square" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;

package/dist/components/data-display/avatar/avatar.variants.js

@@ -0,0 +1,24 @@
+import { cva as e } from "class-variance-authority";
+const r = e(
+  "relative flex shrink-0 overflow-hidden",
+  {
+    variants: {
+      size: {
+        sm: "h-9 w-9 text-xs",
+        md: "h-12 w-12 text-sm",
+        lg: "h-16 w-16 text-lg"
+      },
+      shape: {
+        circle: "rounded-full",
+        square: "rounded-lg"
+      }
+    },
+    defaultVariants: {
+      size: "md",
+      shape: "square"
+    }
+  }
+);
+export {
+  r as avatarVariants
+};

package/dist/components/data-display/avatar/index.d.ts

@@ -0,0 +1,3 @@
+export { Avatar, AvatarImage, AvatarFallback } from './avatar';
+export type { AvatarProps, AvatarImageProps, AvatarFallbackProps } from './avatar.types';
+export { avatarVariants } from './avatar.variants';

package/dist/components/data-display/avatar/index.js

@@ -0,0 +1,8 @@
+import { Avatar as t, AvatarFallback as o, AvatarImage as v } from "./avatar.js";
+import { avatarVariants as m } from "./avatar.variants.js";
+export {
+  t as Avatar,
+  o as AvatarFallback,
+  v as AvatarImage,
+  m as avatarVariants
+};

package/dist/components/data-display/badge/badge.d.ts

@@ -0,0 +1,4 @@
+import { BadgeProps } from './badge.types';
+import * as React from "react";
+declare const Badge: React.ForwardRefExoticComponent<BadgeProps & React.RefAttributes<HTMLDivElement>>;
+export { Badge };

package/dist/components/data-display/badge/badge.js

@@ -0,0 +1,44 @@
+import { jsxs as p, jsx as o } from "react/jsx-runtime";
+import * as b from "react";
+import "class-variance-authority";
+import { createComponent as f } from "../../../lib/primitives/create-component.js";
+import { cn as x } from "../../../lib/utils.js";
+import { badgeVariants as g } from "./badge.variants.js";
+const B = f(
+  "Badge",
+  ({
+    className: l,
+    variant: s,
+    color: d,
+    size: i,
+    shape: m,
+    icon: e,
+    disabled: t,
+    children: a,
+    ...c
+  }, u) => {
+    const r = b.Children.count(a) > 0, n = e != null && !r ? "iconOnly" : "default";
+    return /* @__PURE__ */ p(
+      "div",
+      {
+        ref: u,
+        "data-component": "badge",
+        "data-layout": n,
+        "aria-disabled": t ? !0 : void 0,
+        className: x(
+          g({ variant: s, color: d, size: i, shape: m, layout: n }),
+          t && "pointer-events-none border border-disabled-border bg-disabled-surface text-disabled-foreground",
+          l
+        ),
+        ...c,
+        children: [
+          e != null ? /* @__PURE__ */ o("span", { "data-slot": "badge-icon", className: "inline-flex shrink-0 text-current", children: e }) : null,
+          r ? /* @__PURE__ */ o("span", { className: "min-w-0 flex-1 truncate text-center", children: a }) : null
+        ]
+      }
+    );
+  }
+);
+export {
+  B as Badge
+};

package/dist/components/data-display/badge/badge.types.d.ts

@@ -0,0 +1,7 @@
+import { VariantProps } from 'class-variance-authority';
+import { badgeVariants } from './badge.variants';
+import type * as React from "react";
+export interface BadgeProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "color">, Omit<VariantProps<typeof badgeVariants>, "layout"> {
+    icon?: React.ReactNode;
+    disabled?: boolean;
+}

package/dist/components/data-display/badge/badge.variants.d.ts

@@ -0,0 +1,7 @@
+export declare const badgeVariants: (props?: ({
+    variant?: "outline" | "solid" | "subtle" | null | undefined;
+    color?: "primary" | "destructive" | "warning" | "success" | "neutral" | null | undefined;
+    size?: "sm" | "md" | null | undefined;
+    shape?: "circle" | "square" | null | undefined;
+    layout?: "default" | "iconOnly" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;