impact-nova 2.0.8 → 2.1.0-alpha.1

package/dist/components/forms/select/hooks/useSelectSelectionHandlers.d.ts

@@ -0,0 +1,36 @@
+import { MouseEvent } from 'react';
+import { FlatOption } from '../hooks/useFlattenOptions';
+import { SelectionModel } from '../hooks/useSelectionModel';
+import { ActionMeta, Group, MultiValue, OnChangeValue, Option, SingleValue } from '../select.types';
+export interface SelectVisibleStats {
+    totalVisible: number;
+    selectedVisible: number;
+}
+export interface UseSelectSelectionHandlersParams<OptionType extends Option, IsMulti extends boolean, GroupType extends Group> {
+    isMulti?: boolean;
+    isDisabled?: boolean;
+    isReadOnly: boolean;
+    internalValue: SingleValue<OptionType> | MultiValue<OptionType>;
+    setInternalValue: (value: SingleValue<OptionType> | MultiValue<OptionType>) => void;
+    onChange?: (newValue: OnChangeValue<OptionType, IsMulti>, actionMeta: ActionMeta<OptionType>) => void;
+    onMenuClose?: (value?: OnChangeValue<OptionType, IsMulti>, selectionOrder?: string[]) => void;
+    onClearAll?: () => void;
+    enableSubMenus: boolean;
+    enableGroups: boolean;
+    enableInvertedSelection?: boolean;
+    maxSelectableOptions?: number;
+    closeMenuOnSelect: boolean;
+    options: (OptionType | GroupType)[];
+    flatOptions: FlatOption[];
+    searchValue: string;
+    selectionModel: SelectionModel;
+    visibleStats: SelectVisibleStats;
+    workerSelectAll: <T extends Option>(currentValue: MultiValue<T>, isInverted: boolean, maxSelectable?: number) => Promise<MultiValue<T>>;
+    setIsOpen: (open: boolean) => void;
+    setSearchValue: (value: string) => void;
+}
+export declare function useSelectSelectionHandlers<OptionType extends Option, IsMulti extends boolean, GroupType extends Group>(params: UseSelectSelectionHandlersParams<OptionType, IsMulti, GroupType>): {
+    handleSelect: (option: FlatOption | Option) => void;
+    handleSelectAll: () => Promise<void>;
+    clearValue: (event: MouseEvent) => void;
+};

package/dist/components/forms/select/hooks/useSelectSelectionHandlers.js

@@ -0,0 +1,248 @@
+import { hasSelectableFlatOptions as I, forEachSelectableFlatOption as v, collectSelectableFlatOptionValues as x } from "../utils/selectFlatOptions.js";
+import { isInvertedSelection as h, isOptionArray as V, getLeafOptions as M } from "../utils/select.js";
+function E(e) {
+  const r = (t, b) => {
+    e.onChange && e.onChange(t, b);
+  }, O = (t, b) => {
+    e.onChange && e.onChange(t, b);
+  };
+  return { handleSelect: (t) => {
+    if (!(e.isDisabled || e.isReadOnly || t.isDisabled || ("children" in t || "options" in t) && t.isParentSelectable === !1)) {
+      if (e.isMulti) {
+        const f = e.internalValue || [];
+        if ("children" in t || "options" in t) {
+          const c = M(
+            t,
+            e.enableSubMenus,
+            e.enableGroups
+          ).filter((l) => !l.isDisabled);
+          if (h(f)) {
+            const l = f.excludedValues, s = c.every(
+              (i) => !l.includes(i.value)
+            );
+            let n = [...l];
+            s ? c.forEach((i) => {
+              n.includes(i.value) || n.push(i.value);
+            }) : n = n.filter(
+              (i) => !c.some((d) => d.value === i)
+            );
+            const u = {
+              isAllSelected: !0,
+              excludedValues: n
+            };
+            e.setInternalValue(u), r(u, {
+              action: "select-option",
+              option: t
+            });
+          } else if (V(f)) {
+            const l = f, s = c.every(
+              (u) => l.some((i) => i.value === u.value)
+            );
+            let n = [...l];
+            if (s ? n = n.filter(
+              (u) => !c.some((i) => i.value === u.value)
+            ) : c.forEach((u) => {
+              n.some((i) => i.value === u.value) || n.push(u);
+            }), e.maxSelectableOptions && n.length > e.maxSelectableOptions)
+              return;
+            e.setInternalValue(n), r(n, {
+              action: "select-option",
+              option: t
+            });
+          }
+        } else if (h(f)) {
+          const o = f.excludedValues, c = o.includes(t.value), s = {
+            isAllSelected: !0,
+            excludedValues: c ? o.filter((n) => n !== t.value) : [...o, t.value]
+          };
+          e.setInternalValue(s), r(s, {
+            action: c ? "select-option" : "deselect-option",
+            option: t
+          });
+        } else if (V(f)) {
+          const o = f, c = e.selectionModel.mode === "exclude" ? !e.selectionModel.set.has(t.value) : e.selectionModel.set.has(t.value);
+          let l = [];
+          if (c)
+            l = o.filter((s) => s.value !== t.value);
+          else {
+            if (e.maxSelectableOptions && o.length >= e.maxSelectableOptions)
+              return;
+            l = [...o, t];
+          }
+          e.setInternalValue(l), r(l, {
+            action: c ? "deselect-option" : "select-option",
+            option: t
+          });
+        }
+        return;
+      }
+      if (e.setInternalValue(t), O(t, {
+        action: "select-option",
+        option: t
+      }), e.closeMenuOnSelect) {
+        e.setIsOpen(!1);
+        const f = t;
+        e.onMenuClose?.(f, void 0), e.setSearchValue("");
+      }
+    }
+  }, handleSelectAll: async () => {
+    if (!e.isMulti || e.isDisabled || e.isReadOnly)
+      return;
+    if (e.options.length > 3e3) {
+      try {
+        const l = await e.workerSelectAll(
+          e.internalValue,
+          h(e.internalValue),
+          e.maxSelectableOptions
+        );
+        e.setInternalValue(l), r(l, { action: "select-option" });
+      } catch {
+      }
+      return;
+    }
+    if (e.searchValue) {
+      if (!I(e.flatOptions))
+        return;
+      const l = e.internalValue || [], { totalVisible: s, selectedVisible: n } = e.visibleStats, u = s > 0 && s === n;
+      if (h(l)) {
+        let d = [...l.excludedValues];
+        if (u)
+          v(e.flatOptions, (S) => {
+            d.includes(S.value) || d.push(S.value);
+          });
+        else {
+          const S = x(
+            e.flatOptions
+          );
+          d = d.filter((w) => !S.has(w));
+        }
+        const a = {
+          isAllSelected: !0,
+          excludedValues: d
+        };
+        e.setInternalValue(a), r(a, { action: "select-option" });
+      } else if (V(l)) {
+        let i = [...l];
+        if (u) {
+          const d = x(
+            e.flatOptions
+          );
+          i = i.filter((a) => !d.has(a.value));
+        } else {
+          const d = new Set(i.map((a) => a.value));
+          v(e.flatOptions, (a) => {
+            d.has(a.value) || (i.push(a), d.add(a.value));
+          });
+        }
+        if (e.maxSelectableOptions && i.length > e.maxSelectableOptions)
+          return;
+        e.setInternalValue(i), r(i, {
+          action: "select-option"
+        });
+      }
+      return;
+    }
+    if (e.maxSelectableOptions) {
+      const l = e.internalValue, { totalVisible: s } = e.visibleStats, n = V(l) ? l.length : 0, u = Math.min(s, e.maxSelectableOptions);
+      if (V(l) && n >= u && n > 0) {
+        const i = l.filter((d) => d.isDisabled);
+        e.setInternalValue(i), r(i, { action: "select-option" });
+      } else if (V(l)) {
+        const i = l.filter((a) => a.isDisabled);
+        let d = i.length;
+        for (const a of e.flatOptions) {
+          if (d >= e.maxSelectableOptions)
+            break;
+          a.isGroup || a.isSubmenuParent || a.isDisabled || (i.push(a), d += 1);
+        }
+        e.setInternalValue(i), r(i, { action: "select-option" });
+      }
+      return;
+    }
+    const t = e.internalValue, b = h(t) && t.excludedValues.length === 0;
+    if (e.enableInvertedSelection) {
+      if (b) {
+        const l = V(t) ? t.filter((s) => s.isDisabled) : [];
+        e.setInternalValue(l), r(l, { action: "select-option" });
+      } else {
+        const s = {
+          isAllSelected: !0,
+          excludedValues: e.flatOptions.filter(
+            (n) => n.isDisabled && (V(t) ? !t.some((u) => u.value === n.value) : !0)
+          ).map((n) => n.value)
+        };
+        e.setInternalValue(s), r(s, { action: "select-option" });
+      }
+      return;
+    }
+    const { totalVisible: f, selectedVisible: o } = e.visibleStats;
+    if (f > 0 && f === o) {
+      const l = V(t) ? t.filter((s) => s.isDisabled) : [];
+      e.setInternalValue(l), r(l, { action: "select-option" });
+      return;
+    }
+    const c = V(t) ? t.filter((l) => l.isDisabled) : [];
+    v(e.flatOptions, (l) => {
+      c.push(l);
+    }), e.setInternalValue(c), r(c, { action: "select-option" });
+  }, clearValue: (t) => {
+    if (t.stopPropagation(), e.isReadOnly)
+      return;
+    if (e.isMulti) {
+      const o = [], c = (s) => {
+        for (const n of s) {
+          if (e.enableGroups && "options" in n) {
+            c(
+              n.options
+            );
+            continue;
+          }
+          if (e.enableSubMenus && "children" in n && Array.isArray(n.children)) {
+            c(n.children);
+            continue;
+          }
+          const u = n;
+          u.isDisabled && (e.selectionModel.mode === "exclude" ? !e.selectionModel.set.has(u.value) : e.selectionModel.set.has(u.value)) && o.push(u);
+        }
+      };
+      c(e.options);
+      const l = o;
+      e.setInternalValue(l), r(l, { action: "clear" }), e.onClearAll?.();
+      return;
+    }
+    const b = e.internalValue;
+    if (b) {
+      let o;
+      const c = (l) => {
+        for (const s of l) {
+          if (o)
+            return;
+          if (e.enableGroups && "options" in s) {
+            if (c(
+              s.options
+            ), o)
+              return;
+            continue;
+          }
+          if (e.enableSubMenus && "children" in s && Array.isArray(s.children)) {
+            if (c(s.children), o)
+              return;
+            continue;
+          }
+          const n = s;
+          if (n.value === b.value) {
+            o = n;
+            return;
+          }
+        }
+      };
+      if (c(e.options), o?.isDisabled)
+        return;
+    }
+    const f = null;
+    e.setInternalValue(f), O(f, { action: "clear" }), e.onClearAll?.();
+  } };
+}
+export {
+  E as useSelectSelectionHandlers
+};

package/dist/components/forms/select/hooks/useSelectionModel.d.ts

@@ -0,0 +1,6 @@
+import { Option, SingleValue, MultiValue } from '../select.types';
+export interface SelectionModel {
+    mode: "include" | "exclude";
+    set: Set<string>;
+}
+export declare const useSelectionModel: <OptionType extends Option>(internalValue: SingleValue<OptionType> | MultiValue<OptionType>, isMulti: boolean) => SelectionModel;

package/dist/components/forms/select/hooks/useVisibleStats.d.ts

@@ -0,0 +1,16 @@
+import { Option, Group, SingleValue, MultiValue } from '../select.types';
+import { FlatOption } from './useFlattenOptions';
+import { SelectionModel } from './useSelectionModel';
+interface VisibleStats {
+    totalVisible: number;
+    selectedVisible: number;
+}
+interface GroupStats {
+    selected: number;
+    total: number;
+}
+export declare const useVisibleStats: <OptionType extends Option>(flatOptions: FlatOption[], totalOptionsCount: number, searchValue: string, selectionModel: SelectionModel, internalValue: SingleValue<OptionType> | MultiValue<OptionType>, isMulti: boolean) => {
+    stats: VisibleStats;
+    getGroupStats: (item: Option | Group) => GroupStats;
+};
+export {};

package/dist/components/forms/select/hooks/useVisibleStats.js

@@ -0,0 +1,54 @@
+import { useMemo as h, useRef as g, useEffect as D } from "react";
+const z = (c, f, o, u, b, v) => {
+  const n = h(() => {
+    const t = /* @__PURE__ */ new Set();
+    if (c.length > 0)
+      for (const r of c)
+        r.isDisabled && t.add(r.value);
+    return t;
+  }, [c]), S = h(() => {
+    let t = 0, r = 0;
+    const { mode: a, set: l } = u;
+    if (!o && c.length > 0 && f > 0) {
+      let s = 0;
+      if (a === "include")
+        for (const e of n)
+          l.has(e) && s++;
+      else {
+        let e = 0;
+        for (const d of n)
+          l.has(d) && e++;
+        s = n.size - e;
+      }
+      t = f + s, a === "include" ? r = l.size : r = c.length - l.size;
+    } else
+      for (const s of c)
+        if (!s.isGroup && !s.isSubmenuParent) {
+          const e = a === "exclude" ? !l.has(s.value) : l.has(s.value);
+          (!s.isDisabled || e) && (t++, e && r++);
+        }
+    return { totalVisible: t, selectedVisible: r };
+  }, [
+    c,
+    u,
+    f,
+    o,
+    n
+  ]), i = g(/* @__PURE__ */ new Map());
+  return D(() => {
+    i.current.clear();
+  }, [c, u]), { stats: S, getGroupStats: (t) => {
+    if (i.current.has(t))
+      return i.current.get(t);
+    let r = 0, a = 0;
+    const l = (e) => {
+      "options" in e ? e.options.forEach(l) : "children" in e && Array.isArray(e.children) ? e.children.forEach(l) : e.isDisabled || (a++, (v ? u.mode === "exclude" ? !u.set.has(e.value) : u.set.has(e.value) : b?.value === e.value) && r++);
+    };
+    l(t);
+    const s = { selected: r, total: a };
+    return i.current.set(t, s), s;
+  } };
+};
+export {
+  z as useVisibleStats
+};

package/dist/components/forms/select/index.d.ts

@@ -0,0 +1,3 @@
+export { Select } from './select';
+export * from './select.types';
+export * from './utils/select';

package/dist/components/forms/select/index.js

@@ -0,0 +1,13 @@
+import { Select as n } from "./select.js";
+import { cx as r, getIndeterminateState as i, getLeafOptions as c, getSelectedCount as S, getSequence as a, isInvertedSelection as d, isOptionArray as g, isSelected as l } from "./utils/select.js";
+export {
+  n as Select,
+  r as cx,
+  i as getIndeterminateState,
+  c as getLeafOptions,
+  S as getSelectedCount,
+  a as getSequence,
+  d as isInvertedSelection,
+  g as isOptionArray,
+  l as isSelected
+};

package/dist/components/forms/select/select.constants.d.ts

@@ -0,0 +1,2 @@
+/** Keyboard highlight index for the "Select All" row in multi-select menus. */
+export declare const SELECT_ALL_INDEX = -2;

package/dist/components/forms/select/select.constants.js

@@ -0,0 +1,4 @@
+const E = -2;
+export {
+  E as SELECT_ALL_INDEX
+};

package/dist/components/forms/select/select.d.ts

@@ -0,0 +1,7 @@
+import { SelectProps, Option, Group } from './select.types';
+declare const Select: {
+    <OptionType extends Option = Option, IsMulti extends boolean = boolean, GroupType extends Group = Group>(props: SelectProps<OptionType, IsMulti, GroupType>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Select };
+export type { SelectProps } from './select.types';