@1771technologies/lytenyte-pro 0.0.39

package/dist/sort-manager.js

@@ -0,0 +1,298 @@
+import { jsx } from "react/jsx-runtime";
+import { useMemo, useState, useEffect, createContext, useContext, forwardRef } from "react";
+import { u as useGrid, G as GridProvider } from "./use-grid-DKvzGZWc.js";
+import { clsx } from "@1771technologies/js-utils";
+import { S as Select } from "./select-C6xOZZLq.js";
+import { P as PlusIcon } from "./plus-icon-ToqW5CC-.js";
+import { C as CrossIcon } from "./cross-icon-CEMLAlFX.js";
+function useSortableColumnItems({ state, api }) {
+  const columns = state.columns.use();
+  const candidateColumns = useMemo(() => {
+    return columns.filter((c) => api.columnIsSortable(c));
+  }, [api, columns]);
+  const columnItems = useMemo(() => {
+    return candidateColumns.map((c) => ({ label: c.headerName ?? c.id, value: c.id }));
+  }, [candidateColumns]);
+  return columnItems;
+}
+function sortModelToSortItems(c, grid) {
+  return c.map((c2) => {
+    const columnId = c2.columnId;
+    const sortDirection = c2.isDescending ? "descending" : "ascending";
+    let value = "values";
+    if (c2.options?.isAbsolute) {
+      value += "_absolute";
+    }
+    if (c2.options?.isAccented) {
+      value += "_accented";
+    }
+    if (c2.options?.nullsAppearFirst) {
+      value += "_nulls_first";
+    }
+    const column = grid.api.columnById(c2.columnId);
+    return {
+      columnId,
+      sortDirection,
+      label: column?.headerName ?? column?.id,
+      sortOn: value
+    };
+  });
+}
+function useSortState(grid) {
+  const [state, setState] = useState(() => {
+    const initial = sortModelToSortItems(grid.state.sortModel.peek(), grid);
+    if (initial.length) return initial;
+    return [{ sortDirection: "ascending" }];
+  });
+  useEffect(() => {
+    const dispose = grid.state.sortModel.watch(() => {
+      const nextModel = sortModelToSortItems(grid.state.sortModel.peek(), grid);
+      if (!nextModel.length) setState([{ sortDirection: "ascending" }]);
+      else setState(nextModel);
+    }, false);
+    return () => dispose();
+  }, [grid]);
+  return [state, setState];
+}
+const SortManagerContext = createContext([]);
+const useSortManagerContext = () => useContext(SortManagerContext);
+const SortManagerContainer = forwardRef(function ColumnSortContainer({ className, children, ...props }, ref) {
+  const grid = useGrid();
+  const [state, setState] = useSortManagerContext();
+  const columnItems = useSortableColumnItems(grid);
+  const unselectedSortedColumns = useMemo(() => {
+    const selected = new Set(state.map((c) => c.columnId).filter((c) => c != null));
+    return columnItems.filter((c) => !selected.has(c.value));
+  }, [columnItems, state]);
+  const sortItems = useMemo(() => {
+    return state.map((c, i) => {
+      const columnItem = columnItems.find((s) => c.columnId === s.value) ?? null;
+      const columnOptions = columnItem ? [columnItem, ...unselectedSortedColumns] : unselectedSortedColumns;
+      const columnOnSelect = (column) => {
+        setState((prev) => {
+          const v = { ...prev[i] };
+          v.columnId = column?.value;
+          const next = [...prev];
+          next.splice(i, 1, v);
+          return next;
+        });
+      };
+      const columnSelected = columnItem;
+      const sortOptions = sortValuesValues;
+      const sortSelected = sortValuesValues.find((v) => v.value === c.sortOn) ?? null;
+      const sortOnSelect = (sortOn) => {
+        if (!sortOn) return;
+        setState((prev) => {
+          const v = { ...prev[i] };
+          v.sortOn = sortOn.value;
+          const next = [...prev];
+          next.splice(i, 1, v);
+          return next;
+        });
+      };
+      const sortDirectionOptions = sortDirectionValues;
+      const sortDirectionSelected = c.sortDirection === "ascending" ? { label: "Asc", value: "ascending" } : { label: "Desc", value: "descending" };
+      const sortDirectionOnSelect = (item) => {
+        if (!item) return;
+        setState((prev) => {
+          const v = { ...prev[i] };
+          v.sortDirection = item.value;
+          const next = [...prev];
+          next.splice(i, 1, v);
+          return next;
+        });
+      };
+      const onDelete = () => {
+        setState((prev) => {
+          const next = [...prev];
+          next.splice(i, 1);
+          if (!next.length) {
+            return [{ sortDirection: "ascending" }];
+          }
+          return next;
+        });
+      };
+      const onAdd = () => {
+        setState((prev) => {
+          const next = [...prev];
+          next.splice(i + 1, 0, { sortDirection: "ascending" });
+          return next;
+        });
+      };
+      const maxSortCount = columnItems.length;
+      return {
+        index: i,
+        columnItem,
+        columnOptions,
+        columnSelected,
+        columnOnSelect,
+        sortOptions,
+        sortSelected,
+        sortOnSelect,
+        sortDirectionOptions,
+        sortDirectionSelected,
+        sortDirectionOnSelect,
+        canAdd: maxSortCount > state.length,
+        onAdd,
+        onDelete
+      };
+    });
+  }, [columnItems, setState, state, unselectedSortedColumns]);
+  return /* @__PURE__ */ jsx("div", { ...props, className: clsx("lng1771-sort-manager__container", className), ref, children: children({ items: sortItems }) });
+});
+const sortValuesValues = [
+  { label: "Values", value: "values" },
+  { label: "Absolute", value: "values_absolute" },
+  { label: "Accented", value: "values_accented" },
+  { label: "Nulls First", value: "values_nulls_first" },
+  { label: "Absolute Nulls First", value: "values_absolute_nulls_first" },
+  { label: "Accented Nulls First", value: "values_accented_nulls_first" }
+];
+const sortDirectionValues = [
+  { label: "Asc", value: "ascending" },
+  { label: "Desc", value: "descending" }
+];
+const SortColumnSelect = ({
+  item,
+  placeholder = "Sort by"
+}) => {
+  return /* @__PURE__ */ jsx(
+    Select,
+    {
+      placeholder,
+      selected: item.columnSelected,
+      onSelect: item.columnOnSelect,
+      options: item.columnOptions
+    }
+  );
+};
+const SortSelect = ({
+  item,
+  placeholder = "Select"
+}) => {
+  return /* @__PURE__ */ jsx(
+    Select,
+    {
+      selected: item.sortSelected,
+      onSelect: item.sortOnSelect,
+      options: item.sortOptions,
+      placeholder
+    }
+  );
+};
+const SortDirectionSelection = ({
+  item,
+  placeholder
+}) => {
+  return /* @__PURE__ */ jsx(
+    Select,
+    {
+      selected: item.sortDirectionSelected,
+      onSelect: item.sortDirectionOnSelect,
+      options: item.sortDirectionOptions,
+      placeholder
+    }
+  );
+};
+function SortAdder({ item }) {
+  return /* @__PURE__ */ jsx("button", { className: "lng1771-sort-manager__button", onClick: item.onAdd, disabled: !item.canAdd, children: /* @__PURE__ */ jsx(PlusIcon, { width: 15, height: 15 }) });
+}
+function SortRemover({ item }) {
+  return /* @__PURE__ */ jsx("button", { className: "lng1771-sort-manager__button", onClick: item.onDelete, children: /* @__PURE__ */ jsx(CrossIcon, { width: 16, height: 16 }) });
+}
+function sortItemsToSortModel(sortItems) {
+  return sortItems.filter((c) => {
+    if (!c.columnId) return false;
+    if (!c.sortOn) return false;
+    return true;
+  }).map((c) => {
+    return {
+      columnId: c.columnId,
+      isDescending: c.sortDirection === "descending",
+      options: {
+        isAbsolute: c.sortOn.includes("absolute"),
+        isAccented: c.sortOn.includes("accented"),
+        nullsAppearFirst: c.sortOn.includes("nulls_first")
+      }
+    };
+  });
+}
+const SortApplyButton = forwardRef(
+  function SortApplyButton2({ className, onClick, children, ...props }, ref) {
+    const grid = useGrid();
+    const [state] = useSortManagerContext();
+    return /* @__PURE__ */ jsx(
+      "button",
+      {
+        ...props,
+        className: clsx("lng1771-sort-manager__button", className),
+        onClick: (ev) => {
+          grid.state.sortModel.set(sortItemsToSortModel(state));
+          onClick?.(ev);
+        },
+        ref,
+        children: children ? children : "Apply"
+      }
+    );
+  }
+);
+const SortCancelButton = forwardRef(
+  function SortCancelButton2({ className, onClick, children, ...props }, ref) {
+    const grid = useGrid();
+    const [, setState] = useSortManagerContext();
+    return /* @__PURE__ */ jsx(
+      "button",
+      {
+        ...props,
+        className: clsx("lng1771-sort-manager__button", className),
+        ref,
+        onClick: (ev) => {
+          const model = grid.state.sortModel.peek();
+          if (model.length) setState(sortModelToSortItems(model, grid));
+          else setState([{ sortDirection: "ascending" }]);
+          onClick?.(ev);
+        },
+        children: children ? children : "Cancel"
+      }
+    );
+  }
+);
+const SortClearButton = forwardRef(
+  function SortClearButton2({ className, onClick, children, ...props }, ref) {
+    const grid = useGrid();
+    const [, setState] = useSortManagerContext();
+    return /* @__PURE__ */ jsx(
+      "button",
+      {
+        ...props,
+        className: clsx("lng1771-sort-manager__button", className),
+        ref,
+        onClick: (ev) => {
+          setState([]);
+          grid.state.sortModel.set([]);
+          onClick?.(ev);
+        },
+        children: children ? children : "Clear"
+      }
+    );
+  }
+);
+function SortManagerRoot({ grid, children }) {
+  const state = useSortState(grid);
+  return /* @__PURE__ */ jsx(GridProvider, { value: grid, children: /* @__PURE__ */ jsx(SortManagerContext.Provider, { value: state, children }) });
+}
+const SortManager = {
+  Root: SortManagerRoot,
+  Container: SortManagerContainer,
+  SortColumnSelect,
+  SortSelect,
+  SortDirectionSelect: SortDirectionSelection,
+  SortAdder,
+  SortRemove: SortRemover,
+  SortApply: SortApplyButton,
+  SortCancel: SortCancelButton,
+  SortClear: SortClearButton
+};
+export {
+  SortManager
+};

package/dist/tickmark-icon-CoogRMoO.js

@@ -0,0 +1,51 @@
+import { jsx } from "react/jsx-runtime";
+const ArrowRightIcon = (props) => {
+  return /* @__PURE__ */ jsx(
+    "svg",
+    {
+      width: "20",
+      height: "20",
+      viewBox: "0 0 20 20",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      ...props,
+      children: /* @__PURE__ */ jsx(
+        "path",
+        {
+          d: "M7.5 5L12.5 10L7.5 15",
+          stroke: "currentcolor",
+          strokeWidth: "1.5",
+          strokeLinecap: "round",
+          strokeLinejoin: "round"
+        }
+      )
+    }
+  );
+};
+const TickmarkIcon = (props) => {
+  return /* @__PURE__ */ jsx(
+    "svg",
+    {
+      width: "20",
+      height: "20",
+      viewBox: "0 0 20 20",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      ...props,
+      children: /* @__PURE__ */ jsx(
+        "path",
+        {
+          d: "M3 10.5588L7.64 15.5L17.5 5",
+          stroke: "currentcolor",
+          strokeWidth: "1.5",
+          strokeLinecap: "round",
+          strokeLinejoin: "round"
+        }
+      )
+    }
+  );
+};
+export {
+  ArrowRightIcon as A,
+  TickmarkIcon as T
+};

package/dist/types/cell-selection/cell-selection-containers.d.ts

@@ -0,0 +1,3 @@
+export declare const CellSelectionTop: import('react').NamedExoticComponent<object>;
+export declare const CellSelectionCenter: import('react').NamedExoticComponent<object>;
+export declare const CellSelectionBottom: import('react').NamedExoticComponent<object>;

package/dist/types/cell-selection/cell-selection-driver.d.ts

@@ -0,0 +1 @@
+export declare function CellSelectionDriver(): import("react/jsx-runtime").JSX.Element;

package/dist/types/cell-selection/cell-style-row.d.ts

@@ -0,0 +1,8 @@
+import { CellSelectionRectPro } from '@1771technologies/grid-types/pro';
+export declare function CellStyleRow({ rect, isRowPinnedTop, isDeselect, isRowPinnedBottom, isPivot, }: {
+    rect: CellSelectionRectPro;
+    isRowPinnedTop?: boolean;
+    isDeselect?: boolean;
+    isRowPinnedBottom?: boolean;
+    isPivot?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/column-manager/column-manager-drag-box-controls.d.ts

@@ -0,0 +1 @@
+export declare const ColumnManagerDragBoxControls: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/types/column-manager/column-manager-drag-box-expander.d.ts

@@ -0,0 +1 @@
+export declare const ColumnManagerDragBoxExpander: import('react').ForwardRefExoticComponent<Omit<Omit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "children">, "ref"> & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/types/column-manager/column-manager-drag-box-label.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+export interface ColumnManagerDragBoxLabelProps {
+    icon?: ReactNode;
+}
+export declare const ColumnManagerDragBoxLabel: import('react').ForwardRefExoticComponent<Omit<import('react').ClassAttributes<HTMLDivElement> & import('react').HTMLAttributes<HTMLDivElement> & ColumnManagerDragBoxLabelProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/types/column-manager/column-manager-drag-box.d.ts

@@ -0,0 +1,13 @@
+import { ColumnManagerBoxSource } from './column-manager-types';
+import { PillManagerPillItem } from '../pill-manager/pill-manager-types';
+export declare const ColumnManagerDragBox: import('react').ForwardRefExoticComponent<Omit<import('react').ClassAttributes<HTMLDivElement> & import('react').HTMLAttributes<HTMLDivElement> & {
+    source: ColumnManagerBoxSource;
+}, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+export declare const useDragBox: () => {
+    pillSource: string;
+    dropTags: string[];
+    dropData: {
+        target: string;
+        sourceItems: PillManagerPillItem[];
+    };
+};

package/dist/types/column-manager/column-manager-drag-placeholder.d.ts

@@ -0,0 +1,5 @@
+import { DragActive } from '@1771technologies/lytenyte-core/internal';
+import { ReactNode } from 'react';
+export declare function ColumnManagerDragPlaceholder(props: {
+    readonly children?: (p: DragActive) => ReactNode;
+}): import('react').ReactPortal | null;

package/dist/types/column-manager/column-manager-drop-zone.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { PillManagerPillItem } from '../pill-manager/pill-manager-types';
+export interface ColumnManagerDropZoneProps {
+    children: (p: {
+        pills: PillManagerPillItem[];
+    }) => ReactNode;
+    empty?: ReactNode;
+}
+export declare const ColumnManagerDropZoneVisibility: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+export declare const ColumnManagerDropZone: import('react').ForwardRefExoticComponent<Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "children"> & ColumnManagerDropZoneProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/types/column-manager/column-manager-impl.d.ts

@@ -0,0 +1,36 @@
+import { JSX, ReactNode } from 'react';
+import { ColumnManagerTree } from './column-manager-tree';
+import { ColumnManagerDragPlaceholder } from './column-manager-drag-placeholder';
+import { Separator } from '../components-internal/separator/separator';
+import { PillManagerAggMenuProps } from '../pill-manager/pill-manager-agg-menu';
+import { GridProReact } from '../types';
+interface RootProps<D = any> {
+    readonly aggMenuRenderer?: (p: PillManagerAggMenuProps<D>) => ReactNode;
+    readonly measureMenuRenderer?: (p: PillManagerAggMenuProps<D>) => ReactNode;
+    readonly menuTriggerIcon?: (p: JSX.IntrinsicElements["svg"]) => ReactNode;
+    readonly grid: GridProReact<D>;
+}
+export declare const ColumnManager: {
+    Root: import('react').ForwardRefExoticComponent<Omit<import('react').ClassAttributes<HTMLDivElement> & import('react').HTMLAttributes<HTMLDivElement> & RootProps<any>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    Tree: typeof ColumnManagerTree;
+    TreeItem: import('react').ForwardRefExoticComponent<Omit<import('react').ClassAttributes<HTMLDivElement> & import('react').HTMLAttributes<HTMLDivElement> & {
+        columnItem: import('../list-view/list-view').ListViewItemRendererProps<import('@1771technologies/grid-types/pro-react').ColumnProReact<any>>;
+        depthPadding?: number;
+    }, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    PivotModeToggle: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    Separator: typeof Separator;
+    Search: import('react').ForwardRefExoticComponent<Omit<Omit<import('react').DetailedHTMLProps<import('react').InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "value">, "ref"> & import('react').RefAttributes<HTMLInputElement>>;
+    DragBox: import('react').ForwardRefExoticComponent<Omit<import('react').ClassAttributes<HTMLDivElement> & import('react').HTMLAttributes<HTMLDivElement> & {
+        source: import('./column-manager-types').ColumnManagerBoxSource;
+    }, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    DragBoxControls: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    DragBoxLabel: import('react').ForwardRefExoticComponent<Omit<import('react').ClassAttributes<HTMLDivElement> & import('react').HTMLAttributes<HTMLDivElement> & import('./column-manager-drag-box-label').ColumnManagerDragBoxLabelProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    DragBoxExpander: import('react').ForwardRefExoticComponent<Omit<Omit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "children">, "ref"> & import('react').RefAttributes<HTMLButtonElement>>;
+    DropZoneVisibility: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    DropZone: import('react').ForwardRefExoticComponent<Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "children"> & import('./column-manager-drop-zone').ColumnManagerDropZoneProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    Pill: import('react').ForwardRefExoticComponent<Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "children"> & {
+        item: import('../pill-manager/pill-manager-types').PillManagerPillItem;
+    }, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    DragPlaceholder: typeof ColumnManagerDragPlaceholder;
+};
+export {};

package/dist/types/column-manager/column-manager-pill.d.ts

@@ -0,0 +1,4 @@
+import { PillManagerPillItem } from '../pill-manager/pill-manager-types';
+export declare const ColumnManagerPill: import('react').ForwardRefExoticComponent<Omit<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "children"> & {
+    item: PillManagerPillItem;
+}, "ref"> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/types/column-manager/column-manager-pivot-mode-toggle.d.ts

@@ -0,0 +1 @@
+export declare const PivotModeToggle: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/types/column-manager/column-manager-search.d.ts

@@ -0,0 +1 @@
+export declare const ColumnManagerSearch: import('react').ForwardRefExoticComponent<Omit<Omit<import('react').DetailedHTMLProps<import('react').InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "value">, "ref"> & import('react').RefAttributes<HTMLInputElement>>;

package/dist/types/column-manager/column-manager-state.d.ts

@@ -0,0 +1,8 @@
+import { Dispatch, PropsWithChildren, SetStateAction } from 'react';
+interface ColumnManagerState {
+    readonly query: string;
+    readonly setQuery: Dispatch<SetStateAction<string>>;
+}
+export declare const ColumnStateProvider: (props: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+export declare const useColumnManagerState: () => ColumnManagerState;
+export {};

package/dist/types/column-manager/column-manager-tree-item.d.ts

@@ -0,0 +1,6 @@
+import { ListViewItemRendererProps } from '../list-view/list-view';
+import { ColumnProReact } from '../types';
+export declare const ColumnManagerTreeItem: import('react').ForwardRefExoticComponent<Omit<import('react').ClassAttributes<HTMLDivElement> & import('react').HTMLAttributes<HTMLDivElement> & {
+    columnItem: ListViewItemRendererProps<ColumnProReact<any>>;
+    depthPadding?: number;
+}, "ref"> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/types/column-manager/column-manager-tree.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+import { ListViewItemRendererProps } from '../list-view/list-view';
+import { ColumnProReact } from '../types';
+interface ColumnManagerTreeProps<D> {
+    children: (p: ListViewItemRendererProps<ColumnProReact<D>>) => ReactNode;
+    itemHeight?: number;
+    className?: string;
+    itemClassName?: string;
+}
+export declare function ColumnManagerTree<D>({ className, itemClassName, children, itemHeight, }: ColumnManagerTreeProps<D>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/column-manager/column-manager-types.d.ts

@@ -0,0 +1 @@
+export type ColumnManagerBoxSource = "row-groups" | "column-pivots" | "measures" | "aggregations";

package/dist/types/column-manager/column-manager.d.ts

@@ -0,0 +1 @@
+export { ColumnManager } from './column-manager-impl.js';

package/dist/types/column-manager/column-mananger-context.d.ts

@@ -0,0 +1,12 @@
+import { JSX, ReactNode } from 'react';
+import { PillManagerAggMenuProps } from '../pill-manager/pill-manager-agg-menu';
+export declare const useComponents: () => {
+    readonly aggMenuRenderer: (p: PillManagerAggMenuProps<any>) => ReactNode;
+    readonly measureMenuRenderer: (p: PillManagerAggMenuProps<any>) => ReactNode;
+    readonly menuTriggerIcon: (p: JSX.IntrinsicElements["svg"]) => ReactNode;
+};
+export declare const ColumnMangerContextProvider: import('react').Provider<{
+    readonly aggMenuRenderer: (p: PillManagerAggMenuProps<any>) => ReactNode;
+    readonly measureMenuRenderer: (p: PillManagerAggMenuProps<any>) => ReactNode;
+    readonly menuTriggerIcon: (p: JSX.IntrinsicElements["svg"]) => ReactNode;
+}>;

package/dist/types/column-manager/utils/all-leafs.d.ts

@@ -0,0 +1,3 @@
+import { ColumnProReact } from '@1771technologies/grid-types/pro-react';
+import { PathTreeParentNode } from '@1771technologies/path-tree';
+export declare function allLeafs(c: PathTreeParentNode<ColumnProReact<any>>): ColumnProReact<any>[];

package/dist/types/column-manager/utils/can-hide-item.d.ts

@@ -0,0 +1,3 @@
+import { ApiProReact, ColumnProReact } from '@1771technologies/grid-types/pro-react';
+import { PathTreeNode } from '@1771technologies/path-tree';
+export declare function canHideItem<D>(item: PathTreeNode<ColumnProReact<any>>, api: ApiProReact<D>): boolean;

package/dist/types/column-manager/utils/handle-item-hide.d.ts

@@ -0,0 +1,3 @@
+import { PathTreeNode } from '@1771technologies/path-tree';
+import { ApiProReact, ColumnProReact } from '@1771technologies/grid-types/pro-react';
+export declare function handleItemHide(item: PathTreeNode<ColumnProReact<any>>, api: ApiProReact<any>): void;

package/dist/types/components-internal/button/button.d.ts

@@ -0,0 +1,9 @@
+export declare const Button: import('react').ComponentClass<import('react').ClassAttributes<HTMLButtonElement> & import('react').ButtonHTMLAttributes<HTMLButtonElement> & {
+    kind: "primary" | "secondary" | "tertiary";
+} & {
+    ref?: import('react').Ref<HTMLButtonElement> | undefined;
+}, any> | import('react').FunctionComponent<import('react').ClassAttributes<HTMLButtonElement> & import('react').ButtonHTMLAttributes<HTMLButtonElement> & {
+    kind: "primary" | "secondary" | "tertiary";
+} & {
+    ref?: import('react').Ref<HTMLButtonElement> | undefined;
+}>;

package/dist/types/components-internal/grid-frame/grid-frame.d.ts

@@ -0,0 +1,11 @@
+import { GridProReact } from '@1771technologies/grid-types/pro-react';
+import { SplitPaneAxe } from '@1771technologies/react-split-pane';
+import { PropsWithChildren } from 'react';
+export interface GridFrameConfiguration {
+    readonly axe?: SplitPaneAxe;
+}
+export interface GridFrameProps<D> {
+    readonly grid: GridProReact<D>;
+    readonly axe?: SplitPaneAxe;
+}
+export declare function GridFrame<D>({ grid: { api, state }, children, axe, }: PropsWithChildren<GridFrameProps<D>>): import("react/jsx-runtime").JSX.Element;

package/dist/types/components-internal/radio/radio.d.ts

@@ -0,0 +1,5 @@
+import { ChangeEvent, HTMLProps } from 'react';
+export interface RadioProps {
+    readonly onCheckChange?: (c: boolean, event: ChangeEvent) => void;
+}
+export declare function Radio({ onCheckChange, checked, disabled, ...other }: Omit<HTMLProps<HTMLInputElement>, "onChange"> & RadioProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components-internal/separator/separator.d.ts

@@ -0,0 +1,8 @@
+import { CSSProperties } from 'react';
+export interface SeparatorProps {
+    readonly dir: "vertical" | "horizontal";
+    readonly soft?: boolean;
+    readonly className?: string;
+    readonly style?: CSSProperties;
+}
+export declare function Separator(props: SeparatorProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components-internal/toggle/toggle.d.ts

@@ -0,0 +1,7 @@
+export interface ToggleProps {
+    readonly on: boolean;
+    readonly onChange: (b: boolean) => void;
+    readonly disabled?: boolean;
+    readonly id?: string;
+}
+export declare function Toggle({ on, onChange, disabled, id }: ToggleProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/dialog/dialog-driver.d.ts

@@ -0,0 +1 @@
+export declare function DialogDriver(): import("react/jsx-runtime").JSX.Element;

package/dist/types/dialog/dialog-impl.d.ts

@@ -0,0 +1,6 @@
+import { Dialog } from '@base-ui-components/react/dialog';
+export declare const DialogBackdrop: typeof Dialog.Backdrop;
+export declare const DialogPopup: typeof Dialog.Popup;
+export declare const DialogTitle: typeof Dialog.Title;
+export declare const DialogDescription: typeof Dialog.Description;
+export declare const DialogClose: typeof Dialog.Close;

package/dist/types/dialog/dialog.d.ts

@@ -0,0 +1,8 @@
+import { Dialog as D } from '@base-ui-components/react/dialog';
+export declare const Dialog: {
+    Backdrop: typeof D.Backdrop;
+    Close: typeof D.Close;
+    Description: typeof D.Description;
+    Container: typeof D.Popup;
+    Title: typeof D.Title;
+};

package/dist/types/dialog/use-dialog-class.d.ts

@@ -0,0 +1 @@
+export declare function useDialogClass<T>(name: string, className: string | undefined | ((p: T) => string)): string | ((p: T) => string);

package/dist/types/external.d.ts

@@ -0,0 +1,2 @@
+import { Menu } from '@base-ui-components/react/menu';
+export { Menu };

package/dist/types/filter-manager/combined-to-flat.d.ts

@@ -0,0 +1,3 @@
+import { FlatSimpleFilters } from './types';
+import { ColumnFilterProReact, ColumnProReact } from '../types';
+export declare function combinedToFlat<D>(filter: ColumnFilterProReact<D> | undefined | null, column: ColumnProReact<D>): FlatSimpleFilters;

package/dist/types/filter-manager/components/apply-filter-button.d.ts

@@ -0,0 +1 @@
+export declare const FilterManagerApplyButton: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/types/filter-manager/components/clear-filter-button.d.ts

@@ -0,0 +1 @@
+export declare const FilterManagerClearButton: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/types/filter-manager/components/flatten-tree-items.d.ts

@@ -0,0 +1,4 @@
+import { ColumnInFilterItemPro } from '@1771technologies/grid-types/pro';
+export declare function flattenTreeItems(items: ColumnInFilterItemPro[], expansions: Set<string>): (ColumnInFilterItemPro & {
+    depth: number;
+})[];

package/dist/types/filter-manager/components/get-child-values.d.ts

@@ -0,0 +1,2 @@
+import { ColumnInFilterItemParentPro } from '@1771technologies/grid-types/pro';
+export declare function getChildValues(t: ColumnInFilterItemParentPro): Set<unknown>;

package/dist/types/filter-manager/components/in-filter-container.d.ts

@@ -0,0 +1 @@
+export declare const InFilterContainer: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;