impact-nova 2.0.9 → 2.1.0-alpha.10

package/dist/components/feedback/tooltip/tooltip.js

@@ -0,0 +1,57 @@
+import { jsx as i, jsxs as m } from "react/jsx-runtime";
+import * as s from "react";
+import * as r from "@radix-ui/react-tooltip";
+import { wrapRadixPart as c } from "../../../lib/primitives/create-compound.js";
+import { cn as a } from "../../../lib/utils.js";
+import { tooltipVariants as f } from "./tooltip.variants.js";
+function g(t) {
+  return t === "primary" ? "default" : t ?? "tertiary";
+}
+const x = r.Provider, N = (t) => /* @__PURE__ */ i(r.Root, { "data-component": "tooltip", ...t }), R = c(
+  "tooltip",
+  "trigger",
+  "TooltipTrigger",
+  r.Trigger
+), u = s.forwardRef(
+  ({
+    className: t,
+    sideOffset: n = 4,
+    variant: l = "tertiary",
+    showArrow: p = !0,
+    ...e
+  }, d) => {
+    const o = g(l);
+    return /* @__PURE__ */ i(r.Portal, { children: /* @__PURE__ */ m(
+      r.Content,
+      {
+        ref: d,
+        sideOffset: n,
+        "data-component": "tooltip-content",
+        "data-variant": o,
+        className: a(f({ variant: o }), t),
+        ...e,
+        children: [
+          e.children,
+          p && /* @__PURE__ */ i(
+            r.Arrow,
+            {
+              className: a(
+                "fill-current",
+                o === "default" && "fill-brand",
+                o === "secondary" && "fill-background stroke-border",
+                o === "tertiary" && "fill-foreground"
+              )
+            }
+          )
+        ]
+      }
+    ) });
+  }
+);
+u.displayName = r.Content.displayName;
+export {
+  N as Tooltip,
+  u as TooltipContent,
+  x as TooltipProvider,
+  R as TooltipTrigger
+};

package/dist/components/feedback/tooltip/tooltip.types.d.ts

@@ -0,0 +1,11 @@
+import { VariantProps } from 'class-variance-authority';
+import { tooltipVariants } from './tooltip.variants';
+import type * as React from "react";
+import type * as TooltipPrimitive from "@radix-ui/react-tooltip";
+export interface TooltipContentProps extends Omit<React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content>, "variant">, Omit<VariantProps<typeof tooltipVariants>, "variant"> {
+    /**
+     * @deprecated Use `default` — design Primary maps to variant="default".
+     */
+    variant?: VariantProps<typeof tooltipVariants>["variant"] | "primary";
+    showArrow?: boolean;
+}

package/dist/components/feedback/tooltip/tooltip.variants.d.ts

@@ -0,0 +1,3 @@
+export declare const tooltipVariants: (props?: ({
+    variant?: "default" | "secondary" | "tertiary" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;

package/dist/components/feedback/tooltip/tooltip.variants.js

@@ -0,0 +1,19 @@
+import { cva as t } from "class-variance-authority";
+const o = t(
+  "z-[100] overflow-hidden rounded-md px-4 py-2 text-sm animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 origin-[--radix-tooltip-content-transform-origin] motion-reduce:animate-none motion-reduce:transition-none",
+  {
+    variants: {
+      variant: {
+        default: "bg-brand text-brand-foreground",
+        secondary: "bg-canvas text-brand border shadow-md",
+        tertiary: "bg-content text-canvas"
+      }
+    },
+    defaultVariants: {
+      variant: "tertiary"
+    }
+  }
+);
+export {
+  o as tooltipVariants
+};

package/dist/components/flows/accordion-nested-list/accordion-nested-list.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { AccordionNestedListProps } from './accordion-nested-list.types';
+export declare const AccordionNestedList: React.FC<AccordionNestedListProps>;

package/dist/components/flows/accordion-nested-list/accordion-nested-list.js

@@ -0,0 +1,115 @@
+import { jsxs as d, jsx as r } from "react/jsx-runtime";
+import { useState as H, useCallback as u, useMemo as J } from "react";
+import { AccordionItem as K, AccordionTrigger as Q, AccordionContent as R, Accordion as N } from "../../primitives/accordion/accordion.js";
+import { Button as g } from "../../primitives/button/button.js";
+import { NestedList as U } from "../../data/nested-list/nested-list.js";
+import { useAccordionNestedListState as X } from "./hooks/useAccordionNestedListState.js";
+import { SelectionMode as Y } from "../../data/nested-list/nested-list.types.js";
+import { cn as Z } from "../../../lib/utils.js";
+import { useImpactNovaI18n as $ } from "../../../i18n/use-impact-nova-i18n.js";
+const se = ({
+  sections: l,
+  onChange: m,
+  onSubmit: h,
+  onCancel: f,
+  enableApplyDiscard: C = !0,
+  submitButtonLabel: L,
+  cancelButtonLabel: S,
+  className: x = "",
+  enableSearch: B = !0,
+  enableDragDrop: k = !0,
+  enableSelectAll: D = !0,
+  selectionMode: I = Y.CASCADE_DOWN,
+  searchPlaceholder: V,
+  value: j,
+  onValueChange: P,
+  isMultiExpanded: n = !0,
+  defaultCollapseAll: w = !1,
+  validateApply: s
+}) => {
+  const { t: i } = $(), M = L ?? i("nestedList.apply"), O = S ?? i("nestedList.reset"), T = V ?? i("nestedList.searchPlaceholder"), {
+    currentSections: a,
+    hasChanges: c,
+    setCurrentSection: p,
+    saveAllSections: A,
+    discardAllSections: b
+  } = X({ sections: l }), [W, _] = H(() => w ? n ? [] : "" : l.length > 0 ? n ? [l[0].id] : l[0].id : n ? [] : ""), t = j ?? W, v = P ?? _, q = u(
+    (e, o) => {
+      p(e, o), m?.(e, o);
+    },
+    [m, p]
+  ), z = u(() => {
+    A(), h?.(a);
+  }, [a, h, A]), F = u(() => {
+    b(), f?.();
+  }, [b, f]), G = J(() => c ? s ? s(a) : !0 : !1, [c, s, a]), y = l.map((e) => /* @__PURE__ */ d(K, { value: e.id, children: [
+    /* @__PURE__ */ r(Q, { children: e.label }),
+    /* @__PURE__ */ r(R, { className: "min-h-0 h-full", children: /* @__PURE__ */ r("div", { className: "h-full min-h-0 pb-2", children: /* @__PURE__ */ r(
+      U,
+      {
+        items: a[e.id] || [],
+        onChange: (o) => q(e.id, o),
+        enableApplyDiscard: !1,
+        enableSearch: B,
+        enableDragDrop: k,
+        enableSelectAll: D,
+        selectionMode: e.selectionMode ?? I,
+        searchPlaceholder: T,
+        className: "h-full"
+      }
+    ) }) })
+  ] }, e.id));
+  return /* @__PURE__ */ d(
+    "div",
+    {
+      className: Z("flex flex-col h-full", x),
+      "data-component": "accordion-nested-list",
+      "data-has-changes": c ? "" : void 0,
+      children: [
+        /* @__PURE__ */ r("div", { className: "flex-1 min-h-0 overflow-y-auto", children: n ? /* @__PURE__ */ r(
+          N,
+          {
+            type: "multiple",
+            value: Array.isArray(t) ? t : t ? [t] : [],
+            onValueChange: v,
+            className: "space-y-4",
+            children: y
+          }
+        ) : /* @__PURE__ */ r(
+          N,
+          {
+            type: "single",
+            collapsible: !0,
+            value: Array.isArray(t) ? t[0] ?? "" : t,
+            onValueChange: v,
+            className: "space-y-4",
+            children: y
+          }
+        ) }),
+        C && /* @__PURE__ */ d("div", { className: "flex-shrink-0 flex justify-end gap-2 pt-4 border-t mt-4", children: [
+          /* @__PURE__ */ r(
+            g,
+            {
+              variant: "tertiary",
+              onClick: F,
+              disabled: !c,
+              children: O
+            }
+          ),
+          /* @__PURE__ */ r(
+            g,
+            {
+              variant: "default",
+              onClick: z,
+              disabled: !G,
+              children: M
+            }
+          )
+        ] })
+      ]
+    }
+  );
+};
+export {
+  se as AccordionNestedList
+};

package/dist/components/flows/accordion-nested-list/accordion-nested-list.types.d.ts

@@ -0,0 +1,27 @@
+import { NestedListItem, SelectionMode } from '../../data/nested-list/nested-list.types';
+export interface AccordionNestedListSection {
+    id: string;
+    label: string;
+    items: NestedListItem[];
+    selectionMode?: SelectionMode;
+}
+export interface AccordionNestedListProps {
+    sections: AccordionNestedListSection[];
+    onChange?: (sectionId: string, items: NestedListItem[]) => void;
+    onSubmit?: (allSections: Record<string, NestedListItem[]>) => void;
+    onCancel?: () => void;
+    enableApplyDiscard?: boolean;
+    validateApply?: (allSections: Record<string, NestedListItem[]>) => boolean;
+    submitButtonLabel?: string;
+    cancelButtonLabel?: string;
+    className?: string;
+    enableSearch?: boolean;
+    enableDragDrop?: boolean;
+    enableSelectAll?: boolean;
+    selectionMode?: SelectionMode;
+    searchPlaceholder?: string;
+    value?: string | string[];
+    onValueChange?: (value: string | string[]) => void;
+    isMultiExpanded?: boolean;
+    defaultCollapseAll?: boolean;
+}

package/dist/components/flows/accordion-nested-list/hooks/useAccordionNestedListState.d.ts

@@ -0,0 +1,19 @@
+import { NestedListItem } from '../../../data/nested-list/nested-list.types';
+import { AccordionNestedListSection } from '../accordion-nested-list.types';
+interface UseAccordionNestedListStateProps {
+    sections: AccordionNestedListSection[];
+}
+interface UseAccordionNestedListStateReturn {
+    currentSections: Record<string, NestedListItem[]>;
+    savedSections: Record<string, NestedListItem[]>;
+    hasChanges: boolean;
+    setCurrentSection: (sectionId: string, items: NestedListItem[]) => void;
+    saveAllSections: () => void;
+    discardAllSections: () => void;
+}
+/**
+ * Hook to manage state for AccordionNestedList
+ * Tracks current and saved state for all sections
+ */
+export declare const useAccordionNestedListState: ({ sections, }: UseAccordionNestedListStateProps) => UseAccordionNestedListStateReturn;
+export {};

package/dist/components/flows/accordion-nested-list/hooks/useAccordionNestedListState.js

@@ -0,0 +1,36 @@
+import { useMemo as u, useState as o } from "react";
+const g = ({
+  sections: S
+}) => {
+  const t = u(() => {
+    const s = {};
+    return S.forEach((e) => {
+      s[e.id] = JSON.parse(JSON.stringify(e.items));
+    }), s;
+  }, [S]), [n, r] = o(t), [i, a] = o(t), [d, l] = o(t);
+  t !== d && (l(t), r(t), a(t));
+  const N = u(() => Object.keys(n).some((s) => {
+    const e = JSON.stringify(n[s]), c = JSON.stringify(i[s]);
+    return e !== c;
+  }), [n, i]);
+  return {
+    currentSections: n,
+    savedSections: i,
+    hasChanges: N,
+    setCurrentSection: (s, e) => {
+      r((c) => ({
+        ...c,
+        [s]: JSON.parse(JSON.stringify(e))
+      }));
+    },
+    saveAllSections: () => {
+      a(JSON.parse(JSON.stringify(n)));
+    },
+    discardAllSections: () => {
+      r(JSON.parse(JSON.stringify(i)));
+    }
+  };
+};
+export {
+  g as useAccordionNestedListState
+};

package/dist/components/flows/accordion-nested-list/index.d.ts

@@ -0,0 +1,2 @@
+export * from './accordion-nested-list';
+export * from './accordion-nested-list.types';

package/dist/components/flows/command-palette/command-palette-context.d.ts

@@ -0,0 +1,6 @@
+import { CommandPaletteProviderProps } from './command-palette-context.types';
+export declare function CommandPaletteProvider({ children, openKeybinding, storage, }: CommandPaletteProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace CommandPaletteProvider {
+    var displayName: string;
+}
+export type { CommandPaletteContextValue, CommandPaletteProviderProps } from './command-palette-context.types';

package/dist/components/flows/command-palette/command-palette-context.js

@@ -0,0 +1,102 @@
+import { jsx as A } from "react/jsx-runtime";
+import * as s from "react";
+import { ShortcutRegistry as x } from "./shortcut-registry.js";
+import { matchesKeybinding as N } from "./utils.js";
+import { CommandPaletteContext as R } from "./command-palette-react-context.js";
+function T({
+  children: S,
+  openKeybinding: c = { key: "k", meta: !0 },
+  storage: v
+}) {
+  const [e] = s.useState(() => new x(v)), [o, r] = s.useState(!1), [i, K] = s.useState(0);
+  s.useEffect(() => e.subscribe(() => {
+    K((n) => n + 1);
+  }), [e]), s.useEffect(() => {
+    const t = (n) => {
+      const a = n.target, I = a.closest?.("[data-command-palette]"), w = a.tagName === "TEXTAREA" || a.tagName === "SELECT" || a.isContentEditable || a.tagName === "INPUT" && !["checkbox", "radio", "button", "submit", "reset"].includes(
+        a.type
+      );
+      if (N(n, c)) {
+        n.preventDefault(), n.stopPropagation(), r((P) => !P);
+        return;
+      }
+      o || w && !I && !(n.metaKey || n.ctrlKey) || e.handleKeyEvent(n);
+    };
+    return window.addEventListener("keydown", t, !0), () => window.removeEventListener("keydown", t, !0);
+  }, [e, o, c]);
+  const u = s.useCallback(
+    (t) => e.register(t),
+    [e]
+  ), m = s.useCallback(
+    (t) => e.unregister(t),
+    [e]
+  ), l = s.useCallback(
+    (t, n) => e.updateKeybinding(t, n),
+    [e]
+  ), d = s.useCallback(
+    (t) => e.resetKeybinding(t),
+    [e]
+  ), g = s.useCallback(
+    () => e.getPaletteCommands(),
+    [e]
+  ), b = s.useCallback(
+    () => e.getSettingsCommands(),
+    [e]
+  ), p = s.useCallback(
+    (t) => e.getEffectiveKeybinding(t),
+    [e]
+  ), C = s.useCallback(
+    () => e.getRecentCommandIds(),
+    [e]
+  ), f = s.useCallback(
+    (t) => e.pushScope(t),
+    [e]
+  ), k = s.useCallback(
+    (t) => e.popScope(t),
+    [e]
+  ), y = s.useCallback(
+    (t) => e.setActiveInstance(t),
+    [e]
+  ), E = s.useCallback(
+    () => e.getActiveInstance(),
+    [e]
+  ), h = s.useMemo(() => ({
+    registry: e,
+    open: o,
+    setOpen: r,
+    registerCommand: u,
+    unregisterCommand: m,
+    updateKeybinding: l,
+    resetKeybinding: d,
+    getPaletteCommands: g,
+    getSettingsCommands: b,
+    getEffectiveKeybinding: p,
+    getRecentCommandIds: C,
+    pushScope: f,
+    popScope: k,
+    setActiveInstance: y,
+    getActiveInstance: E,
+    version: i
+  }), [
+    e,
+    o,
+    i,
+    u,
+    m,
+    l,
+    d,
+    g,
+    b,
+    p,
+    C,
+    f,
+    k,
+    y,
+    E
+  ]);
+  return /* @__PURE__ */ A(R.Provider, { value: h, children: S });
+}
+T.displayName = "CommandPaletteProvider";
+export {
+  T as CommandPaletteProvider
+};

package/dist/components/flows/command-palette/command-palette-context.types.d.ts

@@ -0,0 +1,51 @@
+import { CommandDefinition, KeyBinding, ShortcutScope, ShortcutStorageAdapter } from './utils';
+import { ConflictInfo, ShortcutRegistry } from './shortcut-registry';
+import type * as React from 'react';
+/** App-wide shortcut registry + palette open state. Consume via `useCommandPalette`. */
+export interface CommandPaletteContextValue {
+    /** The underlying registry instance */
+    registry: ShortcutRegistry;
+    /** Whether the command palette dialog is open */
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    /** Register a command (auto-applies saved overrides) */
+    registerCommand: (command: CommandDefinition) => void;
+    /** Unregister a command by ID */
+    unregisterCommand: (commandId: string) => void;
+    /** Update a command's keybinding (returns conflict info if any) */
+    updateKeybinding: (commandId: string, keybinding: KeyBinding) => {
+        success: boolean;
+        conflict?: ConflictInfo;
+        reserved?: boolean;
+    };
+    /** Reset a command's keybinding to its default */
+    resetKeybinding: (commandId: string) => void;
+    /** Get commands for the palette UI (filtered by scope) */
+    getPaletteCommands: () => CommandDefinition[];
+    /** Get commands for the settings UI */
+    getSettingsCommands: () => CommandDefinition[];
+    /** Get the effective keybinding for a command (with user overrides) */
+    getEffectiveKeybinding: (commandId: string) => KeyBinding | undefined;
+    /** Get recent command IDs */
+    getRecentCommandIds: () => string[];
+    /** Push a shortcut scope onto the stack */
+    pushScope: (scope: ShortcutScope) => void;
+    /** Pop the top shortcut scope */
+    popScope: (scope: ShortcutScope) => void;
+    /** Set/get the currently focused instance (for multi-table dispatch) */
+    setActiveInstance: (instance: string | null) => void;
+    getActiveInstance: () => string | null;
+    /** Force a re-render of consumers (incremented on registry change) */
+    version: number;
+}
+/**
+ * Wrap the app (or layout) once — registers shortcuts, palette open state, scopes.
+ * Pair with a single `<CommandPalette />` instance in the tree.
+ */
+export interface CommandPaletteProviderProps {
+    children: React.ReactNode;
+    /** Custom keybinding to open the palette (defaults to ⌘K / Ctrl+K) */
+    openKeybinding?: KeyBinding;
+    /** Custom storage adapter for shortcuts and recent commands */
+    storage?: ShortcutStorageAdapter;
+}

package/dist/components/flows/command-palette/command-palette-react-context.d.ts

@@ -0,0 +1,3 @@
+import { CommandPaletteContextValue } from './command-palette-context.types';
+import * as React from 'react';
+export declare const CommandPaletteContext: React.Context<CommandPaletteContextValue | null>;

package/dist/components/flows/command-palette/command-palette-react-context.js

@@ -0,0 +1,5 @@
+import * as t from "react";
+const e = t.createContext(null);
+export {
+  e as CommandPaletteContext
+};

package/dist/components/flows/command-palette/command-palette.d.ts

@@ -0,0 +1,28 @@
+import { CommandPaletteProps, CommandPaletteInputProps, CommandPaletteGroupProps, CommandPaletteItemProps, CommandPaletteShortcutProps } from './command-palette.types';
+/**
+ * CommandPalette — The ⌘K overlay with search, grouped results, and keyboard navigation.
+ *
+ * Built from scratch using existing impact-nova Dialog, Input, and Separator components.
+ * Implements fuzzy search, keyboard navigation (↑↓ Enter Esc), recently-used sorting,
+ * and displays shortcut badges via the Kbd component.
+ *
+ * Sub-components exported:
+ *   CommandPalette, CommandPaletteInput, CommandPaletteList,
+ *   CommandPaletteGroup, CommandPaletteItem, CommandPaletteShortcut,
+ *   CommandPaletteEmpty, CommandPaletteSeparator, CommandPaletteFooter
+ */
+import * as React from "react";
+export type { CommandPaletteProps, CommandPaletteLabels, CommandPaletteInputProps, CommandPaletteGroupProps, CommandPaletteItemProps, CommandPaletteShortcutProps, } from './command-palette.types';
+declare function CommandPalette({ className, children, commands: externalCommands, placeholder, emptyTitle, emptyDescription, recentGroupLabel, defaultGroupLabel, navigateLabel, runLabel, closeLabel, configureShortcutsLabel, onCommandExecute, onOpenChange, }: CommandPaletteProps): import("react/jsx-runtime").JSX.Element;
+declare namespace CommandPalette {
+    var displayName: string;
+}
+declare const CommandPaletteInput: React.ForwardRefExoticComponent<CommandPaletteInputProps & React.RefAttributes<HTMLInputElement>>;
+declare const CommandPaletteList: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandPaletteGroup: React.ForwardRefExoticComponent<CommandPaletteGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const CommandPaletteItem: React.NamedExoticComponent<CommandPaletteItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const CommandPaletteShortcut: React.ForwardRefExoticComponent<CommandPaletteShortcutProps & React.RefAttributes<HTMLSpanElement>>;
+declare const CommandPaletteEmpty: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandPaletteSeparator: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandPaletteFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { CommandPalette, CommandPaletteInput, CommandPaletteList, CommandPaletteGroup, CommandPaletteItem, CommandPaletteShortcut, CommandPaletteEmpty, CommandPaletteSeparator, CommandPaletteFooter, };