@vuu-ui/vuu-filters 0.8.8-debug → 0.8.9-debug

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;
+    defaultHighlightedIdx?: number;
+    highlightedIdx?: number;
+    isRoot?: boolean;
+    listItemProps?: Partial<MenuItemProps>;
+    onActivate?: (menuId: string) => void;
+    onCloseMenu: (idx: number) => void;
+    onOpenMenu?: (menuItemEl: HTMLElement) => void;
+    onHighlightMenuItem?: (idx: number) => void;
+}
+export declare const MenuList: {
+    ({ activatedByKeyboard, childMenuShowing, children, className, defaultHighlightedIdx, highlightedIdx: highlightedIdxProp, id: idProp, isRoot, listItemProps, onHighlightMenuItem, onActivate, onCloseMenu, onOpenMenu, ...props }: MenuListProps): JSX.Element;
+    displayName: string;
+};

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,27 @@
+import { FocusEvent, KeyboardEvent } from "react";
+export interface KeyboardNavigationProps {
+    autoHighlightFirstItem?: boolean;
+    count: number;
+    defaultHighlightedIdx?: 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, defaultHighlightedIdx, highlightedIndex: highlightedIndexProp, onActivate, onHighlight, onCloseMenu, onOpenMenu, }: KeyboardNavigationProps) => NavigationHookResult;

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

@@ -0,0 +1,20 @@
+/// <reference types="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;
+    };
+    controlledComponentId?: string;
+};
+export type EventLike = {
+    clientX: number;
+    clientY: number;
+    preventDefault?: () => void;
+    stopPropagation?: () => void;
+};
+export type ShowContextMenu = (e: EventLike, 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/Popup.d.ts

@@ -0,0 +1,10 @@
+import { HTMLAttributes, RefObject } from "react";
+import "./Popup.css";
+export type PopupPlacement = "below" | "below-center" | "below-full-width" | "center" | "right";
+export interface PopupComponentProps extends HTMLAttributes<HTMLDivElement> {
+    placement: PopupPlacement;
+    anchorElement: RefObject<HTMLElement>;
+    offsetLeft?: number;
+    offsetTop?: number;
+}
+export declare const PopupComponent: ({ children, className, anchorElement, placement, }: PopupComponentProps) => JSX.Element | null;

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

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

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

@@ -0,0 +1,59 @@
+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 EscapeClosePopup = {
+    type: "escape";
+    event: KeyboardEvent;
+};
+export type MenuActionClosePopup = {
+    menuId: string;
+    options: ContextMenuOptions;
+    type: "menu-action";
+};
+export type PopupCloseReason = ClickAwayClosePopup | EscapeClosePopup | 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/useAnchoredPosition.d.ts

@@ -0,0 +1,12 @@
+import { RefObject } from "react";
+import { PopupPlacement } from "./Popup";
+export interface AnchoredPositionHookProps {
+    anchorElement: RefObject<HTMLElement>;
+    offsetLeft?: number;
+    offsetTop?: number;
+    placement: PopupPlacement;
+}
+export declare const useAnchoredPosition: ({ anchorElement, offsetLeft, offsetTop, placement, }: AnchoredPositionHookProps) => {
+    left: number;
+    top: number;
+} | undefined;

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

@@ -0,0 +1,16 @@
+import { HTMLAttributes } from "react";
+import { PopupCloseReason } from "@vuu-ui/vuu-popups";
+import "./PopupMenu.css";
+import { MenuActionHandler, MenuBuilder } from "@vuu-ui/vuu-data-types";
+export interface PopupMenuProps extends HTMLAttributes<HTMLButtonElement> {
+    icon?: string;
+    label?: string;
+    menuActionHandler?: MenuActionHandler;
+    menuBuilder?: MenuBuilder;
+    menuLocation?: string;
+    menuOptions?: {
+        [key: string]: unknown;
+    };
+    onMenuClose?: (reason?: PopupCloseReason) => void;
+}
+export declare const PopupMenu: ({ className, label, 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,30 @@
+import { ReactNode } from "react";
+import "./Portal.css";
+export interface PortalProps {
+    /**
+     * The children to render into the `container`.
+     */
+    children?: ReactNode;
+    /**
+     * An HTML element, component instance, or function that returns either.
+     * The `container` will have the portal children appended to it.
+     *
+     * By default, it uses the body of the top-level document object,
+     * so it's simply `document.body` most of the time.
+     */
+    container?: Element | (() => Element | null) | null;
+    /**
+     * If this node does not exist on the document, it will be created for you.
+     */
+    id?: string;
+    /**
+     * Allow conditional rendering of this Portal, if false, will render nothing.
+     * Defaults to true
+     */
+    open?: boolean;
+}
+/**
+ * Portals provide a first-class way to render children into a DOM node
+ * that exists outside the DOM hierarchy of the parent component.
+ */
+export declare const Portal: ({ children, container: containerProp, id, open, }: PortalProps) => import("react").ReactPortal | null;

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

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

package/types/vuu-popups/src/portal-deprecated/PortalDeprecated.d.ts

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

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

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

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

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

package/types/vuu-popups/src/portal-deprecated/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/vuu-popups/src/prompt/Prompt.d.ts

@@ -0,0 +1,14 @@
+import { HTMLAttributes } from "react";
+import { PopupComponentProps } from "../popup";
+import "./Prompt.css";
+export interface PromptProps extends HTMLAttributes<HTMLDialogElement> {
+    PopupProps?: Partial<PopupComponentProps>;
+    cancelButtonLabel?: string;
+    confirmButtonLabel?: string;
+    onCancel: () => void;
+    onConfirm: () => void;
+    icon?: string;
+    text: string;
+    variant?: "warn" | "error" | "info";
+}
+export declare const Prompt: ({ PopupProps, cancelButtonLabel, confirmButtonLabel, icon, onCancel, onConfirm, style, text, title, variant, ...htmlAttributes }: PromptProps) => JSX.Element;

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

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

package/types/vuu-popups/src/tooltip/Tooltip.d.ts

@@ -0,0 +1,12 @@
+import { MouseEventHandler, ReactNode, RefObject } from "react";
+import { TooltipPlacement } from "./useAnchoredPosition";
+import "./Tooltip.css";
+export interface TooltipProps {
+    anchorElement: RefObject<HTMLElement>;
+    children: ReactNode;
+    id?: string;
+    onMouseEnter: MouseEventHandler;
+    onMouseLeave: MouseEventHandler;
+    placement: TooltipPlacement;
+}
+export declare const Tooltip: ({ anchorElement, children, id, onMouseEnter, onMouseLeave, placement, }: TooltipProps) => JSX.Element | null;

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

@@ -0,0 +1,2 @@
+export * from "./Tooltip";
+export * from "./useTooltip";

package/types/vuu-popups/src/tooltip/useAnchoredPosition.d.ts

@@ -0,0 +1,12 @@
+import { RefObject } from "react";
+export type TooltipPlacement = "above" | "right" | "below" | "left";
+export interface AnchoredPositionHookProps {
+    anchorElement: RefObject<HTMLElement>;
+    offsetLeft?: number;
+    offsetTop?: number;
+    placement: TooltipPlacement;
+}
+export declare const useAnchoredPosition: ({ anchorElement, offsetLeft, offsetTop, placement, }: AnchoredPositionHookProps) => {
+    left: number;
+    top: number;
+} | undefined;

package/types/vuu-popups/src/tooltip/useTooltip.d.ts

@@ -0,0 +1,16 @@
+import { MouseEvent, ReactNode } from "react";
+import { TooltipProps } from "./Tooltip";
+import { TooltipPlacement } from "./useAnchoredPosition";
+export interface TooltipHookProps {
+    id: string;
+    placement?: TooltipPlacement;
+    tooltipContent: ReactNode;
+}
+export declare const useTooltip: ({ id: idProp, placement, tooltipContent, }: TooltipHookProps) => {
+    anchorProps: {
+        "aria-describedby": string;
+        onMouseEnter: (evt: MouseEvent) => void;
+        onMouseLeave: () => void;
+    };
+    tooltipProps: TooltipProps | undefined;
+};

package/types/filter-bar/FilterBar.d.ts

@@ -1,9 +0,0 @@
-import { NamedFilter } from "@vuu-ui/vuu-filter-types";
-import { TableSchema } from "@vuu-ui/vuu-data";
-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/filter-bar/index.d.ts

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

package/types/filter-clause/operator-utils.d.ts

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

package/types/filter-pill/FilterPill.d.ts

@@ -1,8 +0,0 @@
-import { NamedFilter } from "@vuu-ui/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/filter-pill-menu/FilterPillMenu.d.ts

@@ -1,12 +0,0 @@
-/// <reference types="react" />
-import { MenuActionHandler } from "@vuu-ui/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;