@linzjs/step-ag-grid 1.4.4 → 1.4.6

package/dist/src/react-menu3/index.d.ts

@@ -0,0 +1,402 @@
+/// <reference types="react" />
+export { useMenuState } from "./hooks";
+export { MenuButton } from "./components/MenuButton";
+export { Menu } from "./components/Menu";
+export { ControlledMenu } from "./components/ControlledMenu";
+export { SubMenu } from "./components/SubMenu";
+export { MenuItem } from "./components/MenuItem";
+export { FocusableItem } from "./components/FocusableItem";
+export { MenuDivider } from "./components/MenuDivider";
+export { MenuHeader } from "./components/MenuHeader";
+export { MenuGroup } from "./components/MenuGroup";
+export { MenuRadioGroup } from "./components/MenuRadioGroup";
+export declare type MenuState = "opening" | "open" | "closing" | "closed";
+export declare type MenuAlign = "start" | "center" | "end";
+export declare type MenuDirection = "left" | "right" | "top" | "bottom";
+export declare type MenuPosition = "auto" | "anchor" | "initial";
+export declare type MenuOverflow = "auto" | "visible" | "hidden";
+export declare type MenuReposition = "auto" | "initial";
+export declare type MenuViewScroll = "auto" | "close" | "initial";
+export declare type MenuItemTypeProp = "checkbox" | "radio";
+export declare type CloseReason = "click" | "cancel" | "blur" | "scroll";
+/**
+ * - `'first'` focus the first item in the menu.
+ * - `'last'` focus the last item in the menu.
+ * - `number` focus item at the specific position (zero-based).
+ */
+export declare type FocusPosition = "first" | "last" | number;
+export declare type ClassNameProp<M = undefined> = string | ((modifiers: M) => string);
+export declare type RenderProp<M, R = React.ReactNode> = R | ((modifiers: M) => R);
+export interface BaseProps<M = undefined> extends Omit<React.HTMLAttributes<HTMLElement>, "className" | "children"> {
+    ref?: React.Ref<any>;
+    /**
+     * Can be a string or a function which receives a modifier object and returns a CSS `class` string.
+     */
+    className?: ClassNameProp<M>;
+}
+export interface Event {
+    /**
+     * The `value` prop passed to the `MenuItem` being clicked.
+     * It's useful for identifying which menu item is clicked.
+     */
+    value?: any;
+    /**
+     *  Indicates the key if the event is triggered by keyboard. Can be 'Enter', ' '(Space) or 'Escape'.
+     */
+    key?: string;
+}
+export interface MenuCloseEvent extends Event {
+    /**
+     * The reason that causes the close event.
+     */
+    reason: CloseReason;
+}
+export interface MenuChangeEvent {
+    /**
+     * Indicates if the menu is open or closed.
+     */
+    open: boolean;
+}
+export interface EventHandler<E> {
+    (event: E): void;
+}
+export interface RectElement {
+    getBoundingClientRect(): {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+        width: number;
+        height: number;
+    };
+}
+export declare type MenuModifiers = Readonly<{
+    /**
+     * Indicates the state of menu.
+     */
+    state: MenuState;
+    /**
+     * Computed direction in which the menu expands.
+     */
+    dir: MenuDirection;
+}>;
+export declare type MenuArrowModifiers = Readonly<{
+    /**
+     * Computed direction in which the menu expands.
+     *
+     * *Please note arrow points to the opposite direction of this value.*
+     */
+    dir: MenuDirection;
+}>;
+export interface MenuStateOptions {
+    /**
+     * By default menu isn't mounted into DOM until it's opened for the first time.
+     * Setting the prop to `true` will change this behaviour,
+     * which also enables menu and its items to be server rendered.
+     */
+    initialMounted?: boolean;
+    /**
+     * By default menu remains in DOM when it's closed.
+     * Setting the prop to `true` will change this behaviour.
+     */
+    unmountOnClose?: boolean;
+    /**
+     * Enable or disable transition effects in `Menu`, `MenuItem`, and any descendent `SubMenu`.
+     *
+     * You can set 'open', 'close' and 'item' at the same time with one boolean value or separately with an object.
+     *
+     * *If you enable transition on menu, make sure to add your own animation styles,
+     * or import `'@szhsin/react-menu/dist/transitions/slide.css'`,
+     * otherwise menu cannot be closed or have visible delay when closed.*
+     *
+     * @example [CodeSandbox Demo](https://codesandbox.io/s/react-menu-sass-i1wxo)
+     */
+    transition?: boolean | {
+        open?: boolean;
+        close?: boolean;
+        item?: boolean;
+    };
+    /**
+     * A fallback timeout in `ms` to stop transition if `onAnimationEnd` events are not fired.
+     *
+     * *Note: this value should be greater than or equal to the duration of
+     * transition animation applied on menu.*
+     *
+     * @default 500
+     */
+    transitionTimeout?: number;
+}
+export interface Hoverable {
+    disabled?: boolean;
+    index?: number;
+}
+/**
+ * Common props for `Menu`, `SubMenu` and `ControlledMenu`
+ */
+interface BaseMenuProps extends Omit<BaseProps, "style"> {
+    /**
+     * Can be a string or a function which receives a modifier object and returns a CSS `class` string.
+     */
+    menuClassName?: ClassNameProp<MenuModifiers>;
+    /**
+     * This prop is forwarded to the `style` prop of menu DOM element.
+     */
+    menuStyle?: React.CSSProperties;
+    /**
+     * Can be a string or a function which receives a modifier object and returns a CSS `class` string.
+     */
+    arrowClassName?: ClassNameProp<MenuArrowModifiers>;
+    /**
+     * This prop is forwarded to the `style` prop of menu arrow DOM element.
+     */
+    arrowStyle?: React.CSSProperties;
+    /**
+     * Set `true` to display an arrow pointing to its anchor element.
+     */
+    arrow?: boolean;
+    /**
+     * Set the horizontal distance (in pixels) between menu and its anchor element.
+     * The value can be negative.
+     * @default 0
+     */
+    offsetX?: number;
+    /**
+     * Set the vertical distance (in pixels) between menu and its anchor element.
+     * The value can be negative.
+     * @default 0
+     */
+    offsetY?: number;
+    /**
+     * Set alignment of menu with anchor element.
+     * @default 'start'
+     */
+    align?: MenuAlign;
+    /**
+     * Set direction in which menu expands against anchor element.
+     * @default 'bottom'
+     */
+    direction?: MenuDirection;
+    /**
+     * Set the position of menu related to its anchor element:
+     *
+     * - 'auto' menu position is adjusted to have it contained within the viewport,
+     * even if it will be detached from the anchor element.
+     * This option allows to display menu in the viewport as much as possible.
+     *
+     * - 'anchor' menu position is adjusted to have it contained within the viewport,
+     * but it will be kept attached to the edges of anchor element.
+     *
+     * - 'initial' menu always stays at its initial position.
+     * @default 'auto'
+     */
+    position?: MenuPosition;
+    /**
+     * Make the menu list scrollable or hidden when there is not enough viewport space to
+     * display all menu items. The prop is similar to the CSS `overflow` property.
+     * @default 'visible'
+     */
+    overflow?: MenuOverflow;
+    /**
+     * Set computed overflow amount down to a child `MenuGroup`.
+     * The `MenuGroup` should have `takeOverflow` prop set as `true` accordingly.
+     */
+    setDownOverflow?: boolean;
+    children?: React.ReactNode;
+}
+export declare type MenuButtonModifiers = Readonly<{
+    /**
+     * Indicates if the associated menu is open.
+     */
+    open: boolean;
+}>;
+export interface MenuInstance {
+    /**
+     * Open menu and optionally request which menu item will be hovered.
+     */
+    openMenu: (position?: FocusPosition, alwaysUpdate?: boolean) => void;
+    /**
+     * Close menu
+     */
+    closeMenu: () => void;
+}
+/**
+ * Common props for `Menu` and `SubMenu`
+ */
+export interface UncontrolledMenuProps {
+    /**
+     * Menu component ref which can be used to programmatically open or close menu.
+     */
+    instanceRef?: React.Ref<MenuInstance>;
+    /**
+     * Event fired after menu is open or closed.
+     */
+    onMenuChange?: EventHandler<MenuChangeEvent>;
+}
+export interface RadioChangeEvent extends Event {
+    /**
+     * The `name` prop passed to the `MenuRadioGroup` when the menu item is in a radio group.
+     */
+    name?: string;
+    /**
+     * Set this property on event object to control whether to keep menu open after menu item is activated.
+     * Leaving it `undefined` will behave in accordance with WAI-ARIA Authoring Practices.
+     */
+    keepOpen?: boolean;
+    /**
+     * Setting this property on event object to `true` will skip `onItemClick` event on root menu component.
+     */
+    stopPropagation?: boolean;
+    /**
+     * DOM event object (React synthetic event)
+     */
+    syntheticEvent: MouseEvent | KeyboardEvent;
+}
+export interface ClickEvent extends RadioChangeEvent {
+    /**
+     * Indicates if the menu item is checked, only for `MenuItem` type="checkbox".
+     */
+    checked?: boolean;
+}
+/**
+ * Common props for `Menu` and `ControlledMenu`
+ */
+export interface RootMenuProps extends BaseMenuProps, MenuStateOptions {
+    /**
+     * Properties of this object are spread to the root DOM element containing the menu.
+     */
+    containerProps?: Omit<React.HTMLAttributes<HTMLElement>, "className">;
+    /**
+     * A ref object attached to a DOM element within which menu will be positioned.
+     * If not provided, the nearest ancestor which has CSS `overflow` set to a value
+     * other than 'visible' or the browser viewport will serve as the bounding box.
+     */
+    boundingBoxRef?: React.RefObject<Element | RectElement>;
+    /**
+     * Specify bounding box padding in pixels. Use a syntax similar to the CSS
+     * `padding` property but sizing units are discarded.
+     * @example '10', '5 10', '1 2 4', or '2 5 3 1'
+     */
+    boundingBoxPadding?: string;
+    /**
+     * Set the behaviour of menu and any of its descendent submenus when window is scrolling:
+     * - 'initial' The window scroll event is ignored and has no effect on menu.
+     * - 'auto' Menu will reposition itself based on the value of `position` prop when window is scrolling.
+     * - 'close' menu will be closed when window is scrolled.
+     * @default 'initial'
+     */
+    viewScroll?: MenuViewScroll;
+    /**
+     * - If `true`, menu is rendered as a direct child of `document.body`,
+     * - or you can specify a target element in the DOM as menu container.
+     *
+     * Portal allows menu to visually “break out” of its container. Typical use cases may include:
+     * - An ancestor container is positioned and CSS `overflow` is set to a value other than `visible`.
+     * - You have a DOM structure that creates a complex hierarchy of stacking contexts,
+     * and menu is overlapped regardless of `z-index` value.
+     */
+    portal?: boolean | {
+        /**
+         * A DOM node under which menu will be rendered.
+         */
+        target?: Element | null;
+        /**
+         * When `target` is null, setting this value `true` prevents menu from rendering into the DOM hierarchy of its parent component.
+         */
+        stablePosition?: boolean;
+    };
+    /**
+     * Specify when menu is repositioned:
+     * - 'initial' Don't automatically reposition menu. Set to this value when you want
+     * to explicitly reposition menu using the `repositionFlag` prop.
+     * - 'auto' Reposition menu whenever its size has changed, using the `ResizeObserver` API.
+     * @default 'auto'
+     */
+    reposition?: MenuReposition;
+    /**
+     * Use this prop to explicitly reposition menu. Whenever the prop has a new value,
+     * menu position will be recalculated and updated.
+     * You might use a counter and increase it every time.
+     *
+     * *Warning: don't update this prop in rapid succession,
+     * which is inefficient and might cause infinite rendering of component.
+     * E.g., don't change the value of this prop in `window` scroll event.*
+     */
+    repositionFlag?: number | string;
+    /**
+     * Set a delay in `ms` before opening a submenu when mouse moves over it.
+     * @default 300
+     */
+    submenuOpenDelay?: number;
+    /**
+     * Set a delay in `ms` before closing a submenu when it's open and mouse is
+     * moving over other items in the parent menu list.
+     * @default 150
+     */
+    submenuCloseDelay?: number;
+    /**
+     * Set a CSS `class` on the container element of menu for theming purpose.
+     */
+    theming?: string;
+    /**
+     * Event fired when descendent menu items are clicked.
+     */
+    onItemClick?: EventHandler<ClickEvent>;
+}
+export interface MenuProps extends RootMenuProps, UncontrolledMenuProps {
+    /**
+     * Can be a `MenuButton`, a `button` element, or a React component.
+     * It also can be a render function that returns one.
+     *
+     * If a React component is provided, it needs to implement the following contracts:
+     * - Accepts a `ref` prop that is forwarded to an element to which menu will be positioned.
+     * The element should be able to receive focus.
+     * - Accepts `onClick` and `onKeyDown` event props.
+     */
+    menuButton: RenderProp<MenuButtonModifiers, React.ReactElement>;
+}
+export interface ControlledMenuProps extends RootMenuProps {
+    /**
+     * Viewport coordinates to which context menu will be positioned.
+     *
+     * *Use this prop only for context menu*
+     */
+    anchorPoint?: {
+        x: number;
+        y: number;
+    };
+    /**
+     * A ref object attached to a DOM element to which menu will be positioned.
+     *
+     * *Don't set this prop for context menu*
+     */
+    anchorRef?: React.RefObject<Element | RectElement>;
+    skipOpen?: React.RefObject<boolean>;
+    /**
+     * If `true`, the menu list element will gain focus after menu is open.
+     * @default true
+     */
+    captureFocus?: boolean;
+    /**
+     * Controls the state of menu. When the prop is `undefined`, menu will be unmounted from DOM.
+     */
+    state?: MenuState;
+    /**
+     * Sets which menu item receives focus (hover) when menu opens.
+     * You will usually set this prop when the menu is opened by keyboard events.
+     *
+     * *Note: If you don't intend to update focus (hover) position,
+     * it's important to keep this prop's identity stable when your component re-renders.*
+     */
+    menuItemFocus?: {
+        position?: FocusPosition;
+        alwaysUpdate?: boolean;
+    };
+    /**
+     * Set the return value of `useMenuState` to this prop.
+     */
+    endTransition?: () => void;
+    /**
+     * Event fired when menu is about to close.
+     */
+    onClose?: EventHandler<MenuCloseEvent>;
+}

package/dist/src/react-menu3/positionUtils/getPositionHelpers.d.ts

@@ -0,0 +1,11 @@
+import { MutableRefObject } from "react";
+export declare const getPositionHelpers: (containerRef: MutableRefObject<HTMLElement>, menuRef: MutableRefObject<HTMLElement>, menuScroll: Window | Element, boundingBoxPadding: string | undefined) => {
+    menuRect: DOMRect;
+    containerRect: DOMRect;
+    getLeftOverflow: (x: number) => number;
+    getRightOverflow: (x: number) => number;
+    getTopOverflow: (y: number) => number;
+    getBottomOverflow: (y: number) => number;
+    confineHorizontally: (x: number) => number;
+    confineVertically: (y: number) => number;
+};

package/dist/src/react-menu3/positionUtils/index.d.ts

@@ -0,0 +1,3 @@
+export { getPositionHelpers } from "./getPositionHelpers";
+export { positionContextMenu } from "./positionContextMenu";
+export { positionMenu } from "./positionMenu";

package/dist/src/react-menu3/positionUtils/placeArrowHorizontal.d.ts

@@ -0,0 +1,8 @@
+import { MutableRefObject } from "react";
+export declare const placeArrowHorizontal: (p: {
+    arrowRef: MutableRefObject<HTMLElement | null>;
+    menuX: number;
+    anchorRect: DOMRect;
+    containerRect: DOMRect;
+    menuRect: DOMRect;
+}) => number;

package/dist/src/react-menu3/positionUtils/placeArrowVertical.d.ts

@@ -0,0 +1,8 @@
+import { MutableRefObject } from "react";
+export declare const placeArrowVertical: (p: {
+    arrowRef: MutableRefObject<HTMLElement | null>;
+    menuY: number;
+    anchorRect: DOMRect;
+    containerRect: DOMRect;
+    menuRect: DOMRect;
+}) => number;

package/dist/src/react-menu3/positionUtils/placeLeftorRight.d.ts

@@ -0,0 +1,19 @@
+import { getPositionHelpers } from "./getPositionHelpers";
+import { MutableRefObject } from "react";
+import { MenuDirection } from "../index";
+export interface placeLeftorRightParams {
+    anchorRect: DOMRect;
+    placeLeftorRightY: number;
+    placeLeftX: number;
+    placeRightX: number;
+    arrowRef: MutableRefObject<HTMLElement | null>;
+    arrow?: boolean;
+    direction: MenuDirection;
+    position: "auto" | "anchor" | "initial";
+}
+export declare const placeLeftorRight: (props: ReturnType<typeof getPositionHelpers> & placeLeftorRightParams) => {
+    arrowY: number | undefined;
+    x: number;
+    y: number;
+    computedDirection: MenuDirection;
+};

package/dist/src/react-menu3/positionUtils/placeToporBottom.d.ts

@@ -0,0 +1,19 @@
+import { getPositionHelpers } from "./getPositionHelpers";
+import { MutableRefObject } from "react";
+import { MenuDirection } from "../index";
+export interface placeToporBottomParams {
+    anchorRect: DOMRect;
+    placeToporBottomX: number;
+    placeTopY: number;
+    placeBottomY: number;
+    arrowRef: MutableRefObject<HTMLElement | null>;
+    arrow?: boolean;
+    direction: "left" | "right" | "top" | "bottom";
+    position: "auto" | "anchor" | "initial";
+}
+export declare const placeToporBottom: (props: ReturnType<typeof getPositionHelpers> & placeToporBottomParams) => {
+    arrowX?: number | undefined;
+    x: number;
+    y: number;
+    computedDirection: MenuDirection;
+};

package/dist/src/react-menu3/positionUtils/positionContextMenu.d.ts

@@ -0,0 +1,13 @@
+import { getPositionHelpers } from "./getPositionHelpers";
+import { MenuDirection } from "../index";
+export declare const positionContextMenu: ({ positionHelpers, anchorPoint, }: {
+    positionHelpers: ReturnType<typeof getPositionHelpers>;
+    anchorPoint: {
+        x: number;
+        y: number;
+    };
+}) => {
+    x: number;
+    y: number;
+    computedDirection: MenuDirection;
+};

package/dist/src/react-menu3/positionUtils/positionMenu.d.ts

@@ -0,0 +1,26 @@
+import { MutableRefObject } from "react";
+import { getPositionHelpers } from "./getPositionHelpers";
+import { MenuDirection } from "../index";
+interface positionMenuProps {
+    offsetX: number;
+    offsetY: number;
+    arrowRef: MutableRefObject<HTMLDivElement | null>;
+    anchorRef: MutableRefObject<HTMLElement | null>;
+    arrow?: boolean;
+    direction: MenuDirection;
+    position: "auto" | "anchor" | "initial";
+    align: "start" | "center" | "end";
+    positionHelpers: ReturnType<typeof getPositionHelpers>;
+}
+export declare const positionMenu: (props: positionMenuProps) => {
+    arrowY: number | undefined;
+    x: number;
+    y: number;
+    computedDirection: MenuDirection;
+} | {
+    arrowX?: number | undefined;
+    x: number;
+    y: number;
+    computedDirection: MenuDirection;
+};
+export {};

package/dist/src/react-menu3/style-utils/index.d.ts

@@ -0,0 +1,11 @@
+declare const menuSelector: {};
+declare const menuArrowSelector: {};
+declare const menuItemSelector: {};
+declare const menuDividerSelector: {};
+declare const menuHeaderSelector: {};
+declare const menuGroupSelector: {};
+declare const radioGroupSelector: {};
+declare const submenuSelector: {};
+declare const menuContainerSelector: {};
+declare const menuButtonSelector: {};
+export { menuContainerSelector, menuButtonSelector, menuSelector, menuArrowSelector, menuItemSelector, menuDividerSelector, menuHeaderSelector, menuGroupSelector, radioGroupSelector, submenuSelector, };

package/dist/src/react-menu3/utils/constants.d.ts

@@ -0,0 +1,92 @@
+import { MutableRefObject } from "react";
+import { EventHandler, FocusPosition, MenuDirection, MenuOverflow, MenuState } from "../index";
+import { RadioChangeEvent } from "../components/MenuRadioGroup";
+import { ControlledMenuProps } from "../components/MenuList";
+export declare const menuContainerClass = "szh-menu-container";
+export declare const menuClass = "szh-menu";
+export declare const menuButtonClass = "szh-menu-button";
+export declare const menuArrowClass = "arrow";
+export declare const menuItemClass = "item";
+export declare const menuDividerClass = "divider";
+export declare const menuHeaderClass = "header";
+export declare const menuGroupClass = "group";
+export declare const subMenuClass = "submenu";
+export declare const radioGroupClass = "radio-group";
+export declare const HoverItemContext: import("react").Context<undefined>;
+interface MenuListItemContextType {
+    isParentOpen?: boolean;
+    isSubmenuOpen?: boolean;
+    dispatch: (actionType: number, item: any, nextIndex: FocusPosition) => void;
+    updateItems: (item: any, isMounted?: boolean) => void;
+    setOpenSubmenuCount: (fn: (count: number) => number) => void;
+}
+export declare const MenuListItemContext: import("react").Context<MenuListItemContextType>;
+export declare const MenuListContext: import("react").Context<{
+    overflow?: MenuOverflow | undefined;
+    overflowAmt?: number | undefined;
+    parentMenuRef?: MutableRefObject<any> | undefined;
+    parentDir?: MenuDirection | undefined;
+    reposSubmenu?: boolean | undefined;
+}>;
+export interface RMEvent {
+    value: any;
+    syntheticEvent: any;
+    checked?: boolean;
+    name?: string;
+    key?: string;
+}
+export declare const EventHandlersContext: import("react").Context<{
+    handleClose?: (() => void) | undefined;
+    handleClick: (event: RMEvent, checked: boolean) => void;
+}>;
+export declare const RadioGroupContext: import("react").Context<{
+    value?: any;
+    name?: string | undefined;
+    onRadioChange?: EventHandler<RadioChangeEvent> | undefined;
+}>;
+interface SettingsContextType extends ControlledMenuProps, MenuListItemContextType {
+    rootMenuRef?: MutableRefObject<any>;
+    rootAnchorRef?: MutableRefObject<any>;
+    scrollNodesRef: MutableRefObject<{
+        anchors?: Element[];
+        menu: any;
+    }>;
+}
+export declare const SettingsContext: import("react").Context<SettingsContextType>;
+export declare const ItemSettingsContext: import("react").Context<{
+    submenuCloseDelay: number;
+    submenuOpenDelay: number;
+}>;
+export declare const Keys: Readonly<{
+    ENTER: "Enter";
+    ESC: "Escape";
+    SPACE: " ";
+    HOME: "Home";
+    END: "End";
+    LEFT: "ArrowLeft";
+    RIGHT: "ArrowRight";
+    UP: "ArrowUp";
+    DOWN: "ArrowDown";
+}>;
+export declare const HoverActionTypes: Readonly<{
+    RESET: 0;
+    SET: 1;
+    UNSET: 2;
+    INCREASE: 3;
+    DECREASE: 4;
+    FIRST: 5;
+    LAST: 6;
+    SET_INDEX: 7;
+}>;
+export declare const CloseReason: Readonly<{
+    CLICK: "click";
+    CANCEL: "cancel";
+    BLUR: "blur";
+    SCROLL: "scroll";
+}>;
+export declare const FocusPositions: Readonly<{
+    FIRST: "first";
+    LAST: "last";
+}>;
+export declare const MenuStateMap: Record<string, MenuState>;
+export {};

package/dist/src/react-menu3/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./constants";
+export * from "./utils";
+export * from "./propTypes";
+export { withHovering } from "./withHovering";