@vuu-ui/vuu-filters 0.8.5-debug → 0.8.6-debug

package/types/vuu-data-react/src/hooks/useServerConnectionQuality.d.ts

@@ -0,0 +1 @@
+export declare const useServerConnectionQuality: () => number;

package/types/vuu-data-react/src/hooks/useServerConnectionStatus.d.ts

@@ -0,0 +1 @@
+export declare const useServerConnectionStatus: () => string;

package/types/vuu-data-react/src/hooks/useTypeaheadSuggestions.d.ts

@@ -0,0 +1,4 @@
+import { TypeaheadParams, VuuTable } from "@vuu-ui/vuu-protocol-types";
+export type SuggestionFetcher = (params: TypeaheadParams) => Promise<string[]>;
+export declare const getTypeaheadParams: (table: VuuTable, column: string, text?: string, selectedValues?: string[]) => TypeaheadParams;
+export declare const useTypeaheadSuggestions: () => SuggestionFetcher;

package/types/vuu-data-react/src/hooks/useVuuMenuActions.d.ts

@@ -0,0 +1,57 @@
+import { DataSource, DataSourceMenusMessage, DataSourceVisualLinkCreatedMessage, DataSourceVisualLinkRemovedMessage, DataSourceVisualLinksMessage, MenuRpcResponse, VuuFeatureInvocationMessage, VuuFeatureMessage, VuuUIMessageInRPCEditReject, VuuUIMessageInRPCEditResponse } from "@vuu-ui/vuu-data";
+import { DataSourceRow, MenuActionHandler, MenuBuilder } from "@vuu-ui/vuu-data-types";
+import { GridAction } from "@vuu-ui/vuu-datagrid-types";
+import { LinkDescriptorWithLabel, VuuMenu, VuuMenuItem, VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import { ColumnMap } from "@vuu-ui/vuu-utils";
+export declare const addRowsFromInstruments = "addRowsFromInstruments";
+export interface VuuCellMenuItem extends VuuMenuItem {
+    rowKey: string;
+    field: string;
+    value: VuuRowDataItemType;
+}
+export interface VuuRowMenuItem extends VuuMenuItem {
+    rowKey: string;
+    row: {
+        [key: string]: VuuRowDataItemType;
+    };
+}
+export declare const isVisualLinksAction: (action: GridAction) => action is DataSourceVisualLinksMessage;
+export declare const isVisualLinkCreatedAction: (action: GridAction) => action is DataSourceVisualLinkCreatedMessage;
+export declare const isVisualLinkRemovedAction: (action: GridAction) => action is DataSourceVisualLinkRemovedMessage;
+export declare const isViewportMenusAction: (action: GridAction) => action is DataSourceMenusMessage;
+export declare const isVuuFeatureAction: (action: GridAction) => action is VuuFeatureMessage;
+export declare const isVuuFeatureInvocation: (action: GridAction) => action is VuuFeatureInvocationMessage;
+export type VuuMenuActionHandler = (type: string, options: unknown) => boolean;
+export interface ViewServerHookResult {
+    buildViewserverMenuOptions: MenuBuilder;
+    handleMenuAction: MenuActionHandler;
+}
+export interface MenuActionConfig {
+    vuuMenu?: VuuMenu;
+    visualLink?: DataSourceVisualLinkCreatedMessage;
+    visualLinks?: LinkDescriptorWithLabel[];
+}
+export type RpcResponseHandler = (response: MenuRpcResponse | VuuUIMessageInRPCEditReject | VuuUIMessageInRPCEditResponse) => void;
+export interface VuuMenuActionHookProps {
+    /**
+     * By default, vuuMenuActions will be handled automatically. When activated, a
+     * message will be sent to server and response will be handled here too.
+     * This prop allows client to provide a custom handler for a menu Item. This will
+     * take priority and if handler returns true, no further processing for the menu
+     * item will be handled by Vuu. This can also be used to prevent an item from being
+     * actioned, even when no custom handling is intended. If the handler returns false,
+     * Vuu will process the menuItem.
+     */
+    clientSideMenuActionHandler?: VuuMenuActionHandler;
+    dataSource: DataSource;
+    menuActionConfig?: MenuActionConfig;
+    onRpcResponse?: RpcResponseHandler;
+}
+export type VuuServerMenuOptions = {
+    columnMap: ColumnMap;
+    columnName: string;
+    row: DataSourceRow;
+    selectedRows: DataSourceRow[];
+    viewport: string;
+};
+export declare const useVuuMenuActions: ({ clientSideMenuActionHandler, dataSource, menuActionConfig, onRpcResponse, }: VuuMenuActionHookProps) => ViewServerHookResult;

package/types/vuu-data-react/src/hooks/useVuuTables.d.ts

@@ -0,0 +1,2 @@
+import { TableSchema } from "@vuu-ui/vuu-data";
+export declare const useVuuTables: () => Map<string, TableSchema> | undefined;

package/types/vuu-data-react/src/index.d.ts

@@ -0,0 +1 @@
+export * from "./hooks";

package/types/vuu-filters/src/filter-bar/FilterBar.d.ts

@@ -0,0 +1,9 @@
+import { NamedFilter } from "@vuu-ui/vuu-filter-types";
+import { TableSchema } from "packages/vuu-data/src";
+import { HTMLAttributes } from "react";
+import "./FilterBar.css";
+export interface FilterbarProps extends HTMLAttributes<HTMLDivElement> {
+    filters: NamedFilter[];
+    tableSchema: TableSchema;
+}
+export declare const FilterBar: ({ className: classNameProp, filters, tableSchema, ...htmlAttributes }: FilterbarProps) => JSX.Element;

package/types/vuu-filters/src/filter-bar/index.d.ts

@@ -0,0 +1 @@
+export * from "./FilterBar";

package/types/vuu-filters/src/filter-clause/ExpandoCombobox.d.ts

@@ -0,0 +1,6 @@
+import { ComboBoxProps, SelectionStrategy } from "@salt-ds/lab";
+import { ForwardedRef, ReactElement } from "react";
+import "./ExpandoCombobox.css";
+export declare const ExpandoCombobox: <Item, Selection_1 extends SelectionStrategy = "default">(props: ComboBoxProps<Item, Selection_1> & {
+    ref?: ForwardedRef<HTMLDivElement> | undefined;
+}) => ReactElement<ComboBoxProps<Item, Selection_1>, string | import("react").JSXElementConstructor<any>>;

package/types/vuu-filters/src/filter-clause/FilterClauseEditor.d.ts

@@ -0,0 +1,13 @@
+import { TableSchema } from "@vuu-ui/vuu-data";
+import { FilterClause } from "@vuu-ui/vuu-filter-types";
+import { HTMLAttributes } from "react";
+import "./FilterClauseEditor.css";
+import { SuggestionFetcher } from "packages/vuu-data-react/src";
+export interface FilterClauseEditorProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    filterClause: Partial<FilterClause>;
+    onChange: (filterClause: Partial<FilterClause>) => void;
+    onClose: () => void;
+    suggestionProvider?: () => SuggestionFetcher;
+    tableSchema: TableSchema;
+}
+export declare const FilterClauseEditor: ({ onChange, onClose, filterClause, suggestionProvider, tableSchema, ...htmlAttributes }: FilterClauseEditorProps) => JSX.Element;

package/types/vuu-filters/src/filter-clause/FilterMenu.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { MenuActionHandler } from "packages/vuu-data-types";
+import "./FilterMenu.css";
+export interface FilterMenuProps {
+    allowAnd?: boolean;
+    allowOr?: boolean;
+    onMenuAction: MenuActionHandler;
+    onMenuClose?: () => void;
+    index: number;
+}
+export declare const FilterMenu: ({ allowAnd, allowOr, onMenuAction, onMenuClose, index, }: FilterMenuProps) => JSX.Element;

package/types/vuu-filters/src/filter-clause/FilterMenuOptions.d.ts

@@ -0,0 +1,6 @@
+import { ContextMenuItemDescriptor } from "packages/vuu-data-types";
+export type MenuOptions = {
+    [key: string]: unknown;
+};
+export declare const andCommand: (options?: MenuOptions) => ContextMenuItemDescriptor;
+export declare const orCommand: (options?: MenuOptions) => ContextMenuItemDescriptor;

package/types/vuu-filters/src/filter-clause/NumericInput.d.ts

@@ -0,0 +1,10 @@
+import { HTMLAttributes, RefObject } from "react";
+import { FilterClauseValueEditor } from "./filterClauseTypes";
+export interface NumericInputProps extends FilterClauseValueEditor, HTMLAttributes<HTMLDivElement> {
+    operatorInputRef?: RefObject<HTMLInputElement>;
+    onValueChange: (value: number) => void;
+    operator: string;
+    ref: RefObject<HTMLDivElement>;
+    value?: number;
+}
+export declare const NumericInput: ({ className, column, onValueChange, value, }: NumericInputProps) => JSX.Element;

package/types/vuu-filters/src/filter-clause/TextInput.d.ts

@@ -0,0 +1,11 @@
+import { HTMLAttributes, RefObject } from "react";
+import { SuggestionFetcher } from "@vuu-ui/vuu-data-react";
+import { FilterClauseValueEditor } from "./filterClauseTypes";
+export interface TextInputProps extends FilterClauseValueEditor, HTMLAttributes<HTMLDivElement> {
+    ref: RefObject<HTMLDivElement>;
+    operator: string;
+    onValueChange: (value: string) => void;
+    suggestionProvider?: () => SuggestionFetcher;
+    value: string;
+}
+export declare const TextInput: import("react").ForwardRefExoticComponent<Omit<TextInputProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/types/vuu-filters/src/filter-clause/filterClauseTypes.d.ts

@@ -0,0 +1,8 @@
+import { ColumnDescriptor } from "packages/vuu-datagrid-types";
+import { FilterClause } from "packages/vuu-filter-types";
+import { VuuTable } from "packages/vuu-protocol-types";
+export interface FilterClauseValueEditor {
+    filterClause: Partial<FilterClause>;
+    column: ColumnDescriptor;
+    table?: VuuTable;
+}

package/types/vuu-filters/src/filter-clause/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ExpandoCombobox";
+export * from "./FilterClauseEditor";

package/types/vuu-filters/src/filter-clause/operator-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const textOperators: string[];
+export declare const numericperators: string[];

package/types/vuu-filters/src/filter-pill/FilterPill.d.ts

@@ -0,0 +1,8 @@
+import { NamedFilter } from "packages/vuu-filter-types";
+import { HTMLAttributes } from "react";
+import "./FilterPill.css";
+export interface FilterPillProps extends HTMLAttributes<HTMLDivElement> {
+    filter: NamedFilter;
+    index?: number;
+}
+export declare const FilterPill: ({ filter, className: classNameProp, index, ...htmlAttributes }: FilterPillProps) => JSX.Element;

package/types/vuu-filters/src/filter-pill/index.d.ts

@@ -0,0 +1 @@
+export * from "./FilterPill";

package/types/vuu-filters/src/filter-pill-menu/FilterPillMenu.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { MenuActionHandler } from "packages/vuu-data-types";
+import "./FilterPillMenu.css";
+export interface FilterPillMenuProps {
+    allowClose?: boolean;
+    allowRename?: boolean;
+    location?: string;
+    onMenuAction: MenuActionHandler;
+    onMenuClose?: () => void;
+    index: number;
+}
+export declare const FilterPillMenu: ({ allowClose, allowRename, location, onMenuAction, onMenuClose, index, }: FilterPillMenuProps) => JSX.Element;

package/types/vuu-filters/src/filter-pill-menu/FilterPillMenuOptions.d.ts

@@ -0,0 +1,10 @@
+import { ContextMenuItemDescriptor } from "packages/vuu-data-types";
+export type MenuOptions = {
+    [key: string]: unknown;
+};
+export interface FilterPillMenuOptions {
+    tabIndex: number;
+}
+export declare const isFilterPillMenuOptions: (options: unknown) => options is FilterPillMenuOptions;
+export declare const closeCommand: (options?: MenuOptions) => ContextMenuItemDescriptor;
+export declare const renameCommand: (options?: MenuOptions) => ContextMenuItemDescriptor;

package/types/vuu-filters/src/filter-pill-menu/index.d.ts

@@ -0,0 +1 @@
+export * from "./FilterPillMenu";

package/types/{filter-utils.d.ts → vuu-filters/src/filter-utils.d.ts}

@@ -1,6 +1,5 @@
 import { ColumnDescriptor } from "@vuu-ui/vuu-datagrid-types";
-import { Filter, FilterClause, FilterCombinatorOp } from "@vuu-ui/vuu-filter-types";
-import { NumericOperator } from "./operator-utils";
+import { Filter, FilterClause, FilterCombinatorOp, NumericFilterClauseOp } from "@vuu-ui/vuu-filter-types";
 export declare const AND = "and";
 export declare const EQUALS = "=";
 export declare const GREATER_THAN = ">";
@@ -39,5 +38,5 @@ export declare const filterIncludesColumn: (filter: Filter, column: ColumnDescri
 export declare const filterEquals: (f1?: Filter, f2?: Filter, strict?: boolean) => boolean;
 export declare const updateFilter: (filter: Filter | undefined, newFilter: Filter | undefined, mode: "add" | "replace") => Filter | undefined;
 export declare const getTypeaheadFilter: (column: string, filterValues: string[], isStartsWithFilter?: boolean) => Filter | undefined;
-export declare const getNumericFilter: (column: string, operator?: NumericOperator, value?: number) => Filter | undefined;
+export declare const getNumericFilter: (column: string, op?: NumericFilterClauseOp, value?: number) => FilterClause | undefined;
 export {};

package/types/{index.d.ts → vuu-filters/src/index.d.ts}

@@ -1,3 +1,4 @@
+export * from "./filter-bar";
+export * from "./filter-clause";
 export * from "./filter-input";
-export * from "./filter-toolbar";
 export * from "./filter-utils";

package/types/vuu-popups/src/dialog/Dialog.d.ts

@@ -0,0 +1,7 @@
+import { HTMLAttributes } from "react";
+import "./Dialog.css";
+export interface DialogProps extends HTMLAttributes<HTMLDivElement> {
+    isOpen?: boolean;
+    onClose?: () => void;
+}
+export declare const Dialog: ({ children, className, isOpen, onClose, title, ...props }: DialogProps) => JSX.Element | null;

package/types/vuu-popups/src/dialog/index.d.ts

@@ -0,0 +1 @@
+export * from "./Dialog";

package/types/vuu-popups/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./dialog";
+export * from "./menu";
+export * from "./popup";
+export * from "./popup-menu";
+export * from "./portal";

package/types/vuu-popups/src/menu/ContextMenu.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { MenuListProps } from "./MenuList";
+import { PopupCloseCallback } from "../popup";
+export interface ContextMenuProps extends Omit<MenuListProps, "onCloseMenu"> {
+    onClose?: PopupCloseCallback;
+    position?: {
+        x: number;
+        y: number;
+    };
+    withPortal?: boolean;
+}
+export declare const ContextMenu: {
+    ({ activatedByKeyboard, children: childrenProp, className, id: idProp, onClose, position, style, ...menuListProps }: ContextMenuProps): JSX.Element;
+    displayName: string;
+};

package/types/vuu-popups/src/menu/MenuList.d.ts

@@ -0,0 +1,43 @@
+import React, { FC, HTMLAttributes, ReactElement, ReactNode } from "react";
+import "./MenuList.css";
+export declare const Separator: () => JSX.Element;
+export interface MenuItemGroupProps {
+    children: ReactElement<MenuItemProps>[] | [ReactElement<MenuItemLabelProps>, ...ReactElement<MenuItemProps>[]];
+    label?: string;
+}
+export interface MenuItemProps extends HTMLAttributes<HTMLDivElement> {
+    action?: string;
+    idx?: number;
+    options?: unknown;
+}
+export declare const MenuItemGroup: FC<MenuItemGroupProps>;
+export declare const MenuItem: {
+    ({ children, idx, ...props }: MenuItemProps): JSX.Element;
+    Label: {
+        ({ children }: {
+            children: ReactNode;
+        }): JSX.Element;
+        displayName: string;
+    };
+};
+export interface MenuItemLabelProps {
+    children: ReactNode;
+}
+export declare const isMenuItemLabel: (item: ReactNode) => item is React.ReactElement<MenuItemLabelProps, string | React.JSXElementConstructor<any>>;
+export interface MenuListProps extends HTMLAttributes<HTMLDivElement> {
+    activatedByKeyboard?: boolean;
+    children: ReactElement[];
+    childMenuShowing?: string;
+    highlightedIdx?: number;
+    isRoot?: boolean;
+    listItemProps?: Partial<MenuItemProps>;
+    onActivate?: (menuId: string) => void;
+    onCloseMenu: (idx: number) => void;
+    onOpenMenu?: (menuItemEl: HTMLElement) => void;
+    onHighlightMenuItem?: (idx: number) => void;
+}
+declare const MenuList: {
+    ({ activatedByKeyboard, childMenuShowing, children, className, highlightedIdx: highlightedIdxProp, id: idProp, isRoot, listItemProps, onHighlightMenuItem, onActivate, onCloseMenu, onOpenMenu, ...props }: MenuListProps): JSX.Element;
+    displayName: string;
+};
+export default MenuList;

package/types/vuu-popups/src/menu/context-menu-provider.d.ts

@@ -0,0 +1,10 @@
+import type { ContextMenuContextType, MenuActionHandler, MenuBuilder } from "@vuu-ui/vuu-data-types";
+import { ReactNode } from "react";
+export declare const ContextMenuContext: import("react").Context<ContextMenuContextType | null>;
+export interface ContextMenuProviderProps {
+    children: ReactNode;
+    label?: string;
+    menuActionHandler?: MenuActionHandler;
+    menuBuilder: MenuBuilder;
+}
+export declare const ContextMenuProvider: ({ children, label, menuActionHandler, menuBuilder, }: ContextMenuProviderProps) => JSX.Element;

package/types/vuu-popups/src/menu/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ContextMenu";
+export * from "./MenuList";
+export * from "./context-menu-provider";
+export * from "./useContextMenu";

package/types/vuu-popups/src/menu/key-code.d.ts

@@ -0,0 +1,12 @@
+export declare const ArrowUp = "ArrowUp";
+export declare const ArrowDown = "ArrowDown";
+export declare const ArrowLeft = "ArrowLeft";
+export declare const Backspace = "Backspace";
+export declare const ArrowRight = "ArrowRight";
+export declare const Enter = "Enter";
+export declare const Escape = "Escape";
+export declare const Delete = "Delete";
+export declare const isCharacterKey: (evt: KeyboardEvent) => boolean | undefined;
+export declare const isNavigationKey: ({ key }: {
+    key: string;
+}, orientation?: string) => boolean;

package/types/vuu-popups/src/menu/list-dom-utils.d.ts

@@ -0,0 +1,4 @@
+export declare function listItemIndex(listItemEl: HTMLElement): number | undefined;
+export declare const closestListItem: (el: HTMLElement | null | undefined) => HTMLElement;
+export declare const closestListItemId: (el: HTMLElement) => string | undefined;
+export declare const closestListItemIndex: (el: HTMLElement) => number | undefined;

package/types/vuu-popups/src/menu/use-cascade.d.ts

@@ -0,0 +1,25 @@
+import { MouseEvent } from "react";
+import { MenuItemProps } from "./MenuList";
+export type RuntimeMenuDescriptor = {
+    id: string;
+    left: number;
+    top: number;
+};
+export declare const getHostMenuId: (id: string, rootId: string) => string;
+export interface CascadeHookProps {
+    id: string;
+    onActivate: (menuId: string) => void;
+    onMouseEnterItem: (evt: MouseEvent, itemId: string) => void;
+    position: {
+        x: number;
+        y: number;
+    };
+}
+export interface CascadeHooksResult {
+    closeMenu: () => void;
+    handleRender: () => void;
+    listItemProps: Partial<MenuItemProps>;
+    openMenu: (menuItemEl: HTMLElement) => void;
+    openMenus: RuntimeMenuDescriptor[];
+}
+export declare const useCascade: ({ id: rootId, onActivate, onMouseEnterItem, position: { x: posX, y: posY }, }: CascadeHookProps) => CascadeHooksResult;

package/types/vuu-popups/src/menu/use-items-with-ids-next.d.ts

@@ -0,0 +1,13 @@
+import { ReactElement } from "react";
+export declare const isMenuItemGroup: (child: ReactElement) => boolean;
+type Menus = {
+    [key: string]: ReactElement[];
+};
+type Actions = {
+    [key: string]: {
+        action: string;
+        options?: unknown;
+    };
+};
+export declare const useItemsWithIdsNext: (childrenProp: ReactElement[], rootId: string) => [Menus, Actions];
+export {};

package/types/vuu-popups/src/menu/use-keyboard-navigation.d.ts

@@ -0,0 +1,26 @@
+import { FocusEvent, KeyboardEvent } from "react";
+export interface KeyboardNavigationProps {
+    autoHighlightFirstItem?: boolean;
+    count: number;
+    highlightedIndex?: number;
+    onActivate: (idx: number) => void;
+    onHighlight?: (idx: number) => void;
+    onCloseMenu: (idx: number) => void;
+    onOpenMenu?: (menuItemEl: HTMLElement) => void;
+}
+export interface KeyboardHookListProps {
+    onFocus: (evt: FocusEvent) => void;
+    onKeyDown: (evt: KeyboardEvent) => void;
+    onMouseDownCapture: () => void;
+    onMouseMove: () => void;
+    onMouseLeave: () => void;
+}
+export interface NavigationHookResult {
+    focusVisible: number;
+    controlledHighlighting: boolean;
+    highlightedIndex: number;
+    setHighlightedIndex: (idx: number) => void;
+    listProps: KeyboardHookListProps;
+    setIgnoreFocus: (ignoreFocus: boolean) => void;
+}
+export declare const useKeyboardNavigation: ({ autoHighlightFirstItem, count, highlightedIndex: highlightedIndexProp, onActivate, onHighlight, onCloseMenu, onOpenMenu, }: KeyboardNavigationProps) => NavigationHookResult;

package/types/vuu-popups/src/menu/useContextMenu.d.ts

@@ -0,0 +1,13 @@
+import { MouseEvent } from "react";
+import { MenuActionHandler, MenuBuilder } from "@vuu-ui/vuu-data-types";
+import { ContextMenuProps } from "./ContextMenu";
+export type ContextMenuOptions = {
+    [key: string]: unknown;
+    contextMenu?: JSX.Element;
+    ContextMenuProps?: Partial<ContextMenuProps> & {
+        className?: string;
+        "data-mode"?: string;
+    };
+};
+export type ShowContextMenu = (e: MouseEvent<HTMLElement>, location: string, options: ContextMenuOptions) => void;
+export declare const useContextMenu: (menuBuilder?: MenuBuilder, menuActionHandler?: MenuActionHandler) => [ShowContextMenu, () => void];

package/types/vuu-popups/src/menu/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const isRoot: (el: HTMLElement) => boolean;
+export declare const hasPopup: (el: HTMLElement, idx: number) => boolean;

package/types/vuu-popups/src/popup/index.d.ts

@@ -0,0 +1 @@
+export * from "./popup-service";

package/types/vuu-popups/src/popup/popup-service.d.ts

@@ -0,0 +1,55 @@
+import React, { ReactElement } from "react";
+import { ContextMenuOptions } from "../menu";
+import "./popup-service.css";
+export type PopupCloseCallback = (reason?: PopupCloseReason) => void;
+export type ClickAwayClosePopup = {
+    type: "click-away";
+    mouseEvt: MouseEvent;
+};
+export type MenuActionClosePopup = {
+    menuId: string;
+    options: ContextMenuOptions;
+    type: "menu-action";
+};
+export type PopupCloseReason = ClickAwayClosePopup | MenuActionClosePopup;
+export declare const reasonIsMenuAction: (reason?: PopupCloseReason) => reason is MenuActionClosePopup;
+export declare const reasonIsClickAway: (reason?: PopupCloseReason) => reason is ClickAwayClosePopup;
+export interface ShowPopupProps {
+    depth?: number;
+    /**
+     * if true, focus will be invoked on first focusable element
+     */
+    focus?: boolean;
+    name?: string;
+    group?: string;
+    position?: "above" | "below" | "";
+    left?: number;
+    right?: "auto" | number;
+    top?: number;
+    component: ReactElement;
+    width?: number | "auto";
+}
+export declare class PopupService {
+    static onClose: PopupCloseCallback | undefined;
+    static showPopup({ group, name, left, position, right, top, width, component, }: ShowPopupProps): void;
+    static escapeKeyListener(evt: KeyboardEvent): void;
+    static hidePopup(reason?: PopupCloseReason, name?: string, group?: string): void;
+    static keepWithinThePage(el: HTMLElement, right?: number | "auto"): void;
+}
+export declare class DialogService {
+    static showDialog(dialog: ReactElement): void;
+    static closeDialog(): void;
+}
+export interface PopupProps {
+    children: ReactElement;
+    close?: boolean;
+    depth: number;
+    group?: string;
+    name: string;
+    position?: "above" | "below" | "";
+    width: number;
+}
+export declare const Popup: (props: PopupProps) => React.DetailedReactHTMLElement<{
+    className: string;
+    ref: React.RefObject<HTMLElement>;
+}, HTMLElement>;

package/types/vuu-popups/src/popup-menu/PopupMenu.d.ts

@@ -0,0 +1,14 @@
+import { HTMLAttributes } from "react";
+import "./PopupMenu.css";
+import { MenuActionHandler, MenuBuilder } from "@vuu-ui/vuu-data-types";
+export interface PopupMenuProps extends HTMLAttributes<HTMLButtonElement> {
+    icon?: string;
+    menuActionHandler?: MenuActionHandler;
+    menuBuilder?: MenuBuilder;
+    menuLocation?: string;
+    menuOptions?: {
+        [key: string]: unknown;
+    };
+    onMenuClose?: () => void;
+}
+export declare const PopupMenu: ({ className, icon, id: idProp, menuActionHandler, menuBuilder, menuLocation, menuOptions, onMenuClose, tabIndex, ...htmlAttributes }: PopupMenuProps) => JSX.Element;

package/types/vuu-popups/src/popup-menu/index.d.ts

@@ -0,0 +1 @@
+export * from "./PopupMenu";

package/types/vuu-popups/src/portal/Portal.d.ts

@@ -0,0 +1,8 @@
+import { ReactElement } from "react";
+export interface PortalProps {
+    children: ReactElement;
+    onRender?: () => void;
+    x?: number;
+    y?: number;
+}
+export declare const Portal: ({ children, x, y, onRender, }: PortalProps) => null;

package/types/vuu-popups/src/portal/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Portal";
+export * from "./render-portal";
+export * from "./portal-utils";

package/types/vuu-popups/src/portal/portal-utils.d.ts

@@ -0,0 +1 @@
+export declare const installTheme: (themeId: string) => void;

package/types/vuu-popups/src/portal/render-portal.d.ts

@@ -0,0 +1,10 @@
+import { ReactElement } from "react";
+export interface HTMLContainerProps {
+    className?: string;
+    dataMode?: string;
+    x?: number;
+    y?: number;
+    win?: typeof globalThis;
+}
+export declare const createContainer: (props: HTMLContainerProps) => HTMLDivElement;
+export declare const renderPortal: (component: ReactElement, container: HTMLElement, x: number, y: number, onRender?: () => void) => void;

package/types/filter-clause/FilterClause.d.ts

@@ -1,13 +0,0 @@
-import { HTMLAttributes } from "react";
-import { ColumnDescriptor } from "@vuu-ui/vuu-datagrid-types";
-import { Filter, FilterClause as FilterClauseType } from "@vuu-ui/vuu-filter-types";
-import { VuuTable } from "@vuu-ui/vuu-protocol-types";
-import "./FilterClause.css";
-export type FilterClauseProps = Omit<HTMLAttributes<HTMLDivElement>, "onChange"> & {
-    table: VuuTable;
-    onChange: (filter?: Filter) => void;
-    onClose: () => void;
-    columns: ColumnDescriptor[];
-    defaultFilter?: FilterClauseType;
-};
-export declare const FilterClause: ({ table, onChange, onClose, columns, defaultFilter, ...htmlAttributes }: FilterClauseProps) => JSX.Element;

package/types/filter-clause/NumericInput.d.ts

@@ -1,10 +0,0 @@
-import { HTMLAttributes, RefObject } from "react";
-import { Filter, FilterClause } from "@vuu-ui/vuu-filter-types";
-type NumericInputProps = HTMLAttributes<HTMLDivElement> & {
-    column: string;
-    operatorInputRef: RefObject<HTMLInputElement>;
-    onFilterChange: (filter?: Filter) => void;
-    defaultFilter?: FilterClause;
-};
-export declare const NumericInput: ({ column, operatorInputRef, onFilterChange, defaultFilter, className, }: NumericInputProps) => JSX.Element;
-export {};

package/types/filter-clause/TextInput.d.ts

@@ -1,12 +0,0 @@
-import { HTMLAttributes, RefObject } from "react";
-import { Filter, FilterClause } from "@vuu-ui/vuu-filter-types";
-import { VuuTable } from "@vuu-ui/vuu-protocol-types";
-type TextInputProps = HTMLAttributes<HTMLDivElement> & {
-    table: VuuTable;
-    column: string;
-    operatorInputRef: RefObject<HTMLInputElement>;
-    onFilterChange: (filter?: Filter) => void;
-    defaultFilter?: FilterClause;
-};
-export declare const TextInput: ({ table, column, operatorInputRef, onFilterChange, defaultFilter, className, }: TextInputProps) => JSX.Element;
-export {};

package/types/filter-clause/index.d.ts

@@ -1 +0,0 @@
-export * from "./FilterClause";

package/types/filter-toolbar/FilterDropdown.d.ts

@@ -1,8 +0,0 @@
-/// <reference types="react" />
-import { DropdownProps } from "@heswell/salt-lab";
-import { IFilterSuggestionProvider } from "../filter-input";
-export interface FilterDropdownProps extends DropdownProps {
-    column: string;
-    suggestionProvider: IFilterSuggestionProvider;
-}
-export declare const FilterDropdown: ({ column, selected: selectedProp, suggestionProvider, ...props }: FilterDropdownProps) => JSX.Element;

package/types/filter-toolbar/FilterDropdownMultiSelect.d.ts

@@ -1,8 +0,0 @@
-/// <reference types="react" />
-import { DropdownProps } from "@heswell/salt-lab";
-import { IFilterSuggestionProvider } from "../filter-input";
-export interface FilterDropdownProps extends DropdownProps<string, "multiple"> {
-    column: string;
-    suggestionProvider: IFilterSuggestionProvider;
-}
-export declare const FilterDropdownMultiSelect: ({ column, selected: selectedProp, suggestionProvider, ...props }: FilterDropdownProps) => JSX.Element;

package/types/filter-toolbar/FilterToolbar.d.ts

@@ -1,9 +0,0 @@
-/// <reference types="react" />
-import { Filter } from "@vuu-ui/vuu-filter-types";
-import { ToolbarProps } from "@heswell/salt-lab";
-import { SuggestionConsumer } from "../filter-input";
-import "./FilterToolbar.css";
-export interface FilterToolbarProps extends SuggestionConsumer, ToolbarProps {
-    filter?: Filter;
-}
-export declare const FilterToolbar: ({ className, filter, suggestionProvider, ...props }: FilterToolbarProps) => JSX.Element;