@gusarov-studio/rubik-ui 3.9.1 → 3.11.0

package/dist/ModalsManager/ModalDef.d.ts

@@ -0,0 +1,9 @@
+import type React from "react";
+import type { ModalProps } from "./types";
+interface ModalDefProps {
+    modalId: string;
+    component: React.ComponentType<any>;
+    defaultProps?: ModalProps;
+}
+declare function ModalDef(props: ModalDefProps): null;
+export { ModalDef };

package/dist/ModalsManager/ModalsManagerProvider.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+interface ModalManagerProviderProps {
+    children: React.ReactNode;
+    builtInView?: boolean;
+}
+declare function ModalsManagerProvider(props: ModalManagerProviderProps): React.JSX.Element;
+export { ModalsManagerProvider };

package/dist/ModalsManager/ModalsView.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare function ModalsView(): React.JSX.Element | null;
+export { ModalsView };

package/dist/ModalsManager/constants/actionTypes.d.ts

@@ -0,0 +1,4 @@
+export declare const actionTypes: {
+    readonly OPEN_MODAL: "RUBIK_UI/OPEN_MODAL";
+    readonly CLOSE_MODAL: "RUBIK_UI/CLOSE_MODAL";
+};

package/dist/ModalsManager/context.d.ts

@@ -0,0 +1,2 @@
+declare const ModalsManagerContext: import("react").Context<import("./types").ModalsManagerState | null>;
+export { ModalsManagerContext };

package/dist/ModalsManager/dispatcher.d.ts

@@ -0,0 +1,6 @@
+import type React from "react";
+import type { ModalsAction } from "./types";
+type Dispatcher = React.Dispatch<ModalsAction>;
+declare function registerDispatcher(dispatch: Dispatcher): void;
+declare function dispatch(action: ModalsAction): void;
+export { registerDispatcher, dispatch };

package/dist/ModalsManager/hooks/useModals.d.ts

@@ -0,0 +1,3 @@
+import type { ModalsManager } from "../types";
+declare function useModals(): ModalsManager;
+export { useModals };

package/dist/ModalsManager/hooks/useModalsContext.d.ts

@@ -0,0 +1,2 @@
+declare function useModalsContext(): import("../types").ModalsManagerState;
+export { useModalsContext };

package/dist/ModalsManager/hooks/useModalsState.d.ts

@@ -0,0 +1,5 @@
+import type React from "react";
+import type { ModalsAction, ModalsManagerState } from "../types";
+declare const reducer: (state: ModalsManagerState | undefined, action: ModalsAction) => ModalsManagerState;
+declare function useModalsState(): [ModalsManagerState, React.Dispatch<ModalsAction>];
+export { useModalsState, reducer };

package/dist/ModalsManager/index.d.ts

@@ -0,0 +1,6 @@
+export { ModalsManagerProvider } from "./ModalsManagerProvider";
+export { ModalsView } from "./ModalsView";
+export { ModalDef } from "./ModalDef";
+export { useModals } from "./hooks/useModals";
+export { modalsManager } from "./modalsManager";
+export { type ModalsManager } from "./types";

package/dist/ModalsManager/modalsManager.d.ts

@@ -0,0 +1,8 @@
+import type { ModalProps } from "./types";
+declare const modalsManager: {
+    open(modalId: string, props?: ModalProps): void;
+    close(): void;
+    register: (modalId: string, Component: React.ComponentType<unknown>, defaultProps?: ModalProps) => void;
+    unregister: (modalId: string) => boolean;
+};
+export { modalsManager };

package/dist/ModalsManager/modalsRegistry.d.ts

@@ -0,0 +1,13 @@
+import type React from "react";
+import type { ModalProps, RegistryItem } from "./types";
+declare function register(modalId: string, Component: React.ComponentType<unknown>, defaultProps?: ModalProps): void;
+declare function unregister(modalId: string): boolean;
+declare function get(modalId: string): RegistryItem | undefined;
+declare function has(modalId: string): boolean;
+declare const modalsRegistry: {
+    register: typeof register;
+    unregister: typeof unregister;
+    has: typeof has;
+    get: typeof get;
+};
+export { modalsRegistry };

package/dist/ModalsManager/types.d.ts

@@ -0,0 +1,25 @@
+import type React from "react";
+import type { actionTypes } from "./constants/actionTypes";
+export type ModalProps = Record<string, unknown>;
+export interface ModalsManagerState {
+    activeDialogId: string | null;
+    props: ModalProps;
+}
+export interface ModalsManager {
+    open: (dialogId: string, props?: ModalProps) => void;
+    close: () => void;
+}
+export type ModalsContextState = ModalsManagerState;
+export interface RegistryItem {
+    Component: React.ComponentType<unknown>;
+    props?: ModalProps;
+}
+export type ModalsAction = {
+    type: typeof actionTypes.OPEN_MODAL;
+    payload: {
+        modalId: string;
+        props?: ModalProps;
+    };
+} | {
+    type: typeof actionTypes.CLOSE_MODAL;
+};

package/dist/Tooltip/Tooltip.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+import type { Placement } from "@floating-ui/react";
+import type { CSSUnit } from "../types/CSSUnit";
+type WidthValue = CSSUnit | "0" | `calc(${string})` | number | "auto";
+interface TooltipPropsBase {
+    position?: Placement;
+    width?: WidthValue;
+    withArrow?: boolean;
+    initialOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+interface TooltipProps extends TooltipPropsBase {
+    children: React.ReactNode;
+}
+declare const Tooltip: React.FC<TooltipProps>;
+export { Tooltip, type TooltipPropsBase, type TooltipProps };

package/dist/Tooltip/TooltipContent.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import "./Tooltip.scss";
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<React.HTMLProps<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { TooltipContent };

package/dist/Tooltip/TooltipContext.d.ts

@@ -0,0 +1,54 @@
+import type { useTooltip } from "./hooks/useTooltip";
+type ContextType = ReturnType<typeof useTooltip> | null;
+declare const TooltipContext: import("react").Context<ContextType>;
+declare const useTooltipContext: () => {
+    placement: import("@floating-ui/utils").Placement;
+    strategy: import("@floating-ui/utils").Strategy;
+    middlewareData: import("@floating-ui/core").MiddlewareData;
+    x: number;
+    y: number;
+    isPositioned: boolean;
+    update: () => void;
+    floatingStyles: React.CSSProperties;
+    refs: {
+        reference: import("react").MutableRefObject<import("@floating-ui/react-dom").ReferenceType | null>;
+        floating: React.MutableRefObject<HTMLElement | null>;
+        setReference: (node: import("@floating-ui/react-dom").ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & import("@floating-ui/react").ExtendedRefs<import("@floating-ui/react").ReferenceType>;
+    elements: {
+        reference: import("@floating-ui/react-dom").ReferenceType | null;
+        floating: HTMLElement | null;
+    } & import("@floating-ui/react").ExtendedElements<import("@floating-ui/react").ReferenceType>;
+    context: {
+        x: number;
+        y: number;
+        placement: import("@floating-ui/utils").Placement;
+        strategy: import("@floating-ui/utils").Strategy;
+        middlewareData: import("@floating-ui/core").MiddlewareData;
+        isPositioned: boolean;
+        update: () => void;
+        floatingStyles: React.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event, reason?: import("@floating-ui/react").OpenChangeReason) => void;
+        events: import("@floating-ui/react").FloatingEvents;
+        dataRef: React.MutableRefObject<import("@floating-ui/react").ContextData>;
+        nodeId: string | undefined;
+        floatingId: string | undefined;
+        refs: import("@floating-ui/react").ExtendedRefs<import("@floating-ui/react").ReferenceType>;
+        elements: import("@floating-ui/react").ExtendedElements<import("@floating-ui/react").ReferenceType>;
+    };
+    getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
+    getItemProps: (userProps?: Omit<React.HTMLProps<HTMLElement>, "selected" | "active"> & {
+        active?: boolean;
+        selected?: boolean;
+    }) => Record<string, unknown>;
+    withArrow: boolean;
+    arrowRef: import("react").MutableRefObject<SVGSVGElement | null>;
+    centered: boolean;
+    width: (number | "0" | "auto" | import("../types/CSSUnit").CSSUnit | `calc(${string})`) | undefined;
+    open: boolean;
+    setOpen: (newOpen: boolean) => void;
+};
+export { TooltipContext, type ContextType, useTooltipContext };

package/dist/Tooltip/TooltipTrigger.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+interface TooltipTriggerProps extends React.HTMLProps<HTMLElement> {
+    children: React.ReactNode;
+    asChild?: boolean;
+}
+declare const TooltipTrigger: React.ForwardRefExoticComponent<Omit<TooltipTriggerProps, "ref"> & React.RefAttributes<HTMLElement>>;
+export { TooltipTrigger };

package/dist/Tooltip/hooks/useTooltip.d.ts

@@ -0,0 +1,52 @@
+import type { TooltipPropsBase } from "../Tooltip";
+declare function useTooltip(props?: TooltipPropsBase): {
+    placement: import("@floating-ui/utils").Placement;
+    strategy: import("@floating-ui/utils").Strategy;
+    middlewareData: import("@floating-ui/core").MiddlewareData;
+    x: number;
+    y: number;
+    isPositioned: boolean;
+    update: () => void;
+    floatingStyles: React.CSSProperties;
+    refs: {
+        reference: import("react").MutableRefObject<import("@floating-ui/react-dom").ReferenceType | null>;
+        floating: React.MutableRefObject<HTMLElement | null>;
+        setReference: (node: import("@floating-ui/react-dom").ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & import("@floating-ui/react").ExtendedRefs<import("@floating-ui/react").ReferenceType>;
+    elements: {
+        reference: import("@floating-ui/react-dom").ReferenceType | null;
+        floating: HTMLElement | null;
+    } & import("@floating-ui/react").ExtendedElements<import("@floating-ui/react").ReferenceType>;
+    context: {
+        x: number;
+        y: number;
+        placement: import("@floating-ui/utils").Placement;
+        strategy: import("@floating-ui/utils").Strategy;
+        middlewareData: import("@floating-ui/core").MiddlewareData;
+        isPositioned: boolean;
+        update: () => void;
+        floatingStyles: React.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event, reason?: import("@floating-ui/react").OpenChangeReason) => void;
+        events: import("@floating-ui/react").FloatingEvents;
+        dataRef: React.MutableRefObject<import("@floating-ui/react").ContextData>;
+        nodeId: string | undefined;
+        floatingId: string | undefined;
+        refs: import("@floating-ui/react").ExtendedRefs<import("@floating-ui/react").ReferenceType>;
+        elements: import("@floating-ui/react").ExtendedElements<import("@floating-ui/react").ReferenceType>;
+    };
+    getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
+    getItemProps: (userProps?: Omit<React.HTMLProps<HTMLElement>, "selected" | "active"> & {
+        active?: boolean;
+        selected?: boolean;
+    }) => Record<string, unknown>;
+    withArrow: boolean;
+    arrowRef: import("react").MutableRefObject<SVGSVGElement | null>;
+    centered: boolean;
+    width: (number | "0" | "auto" | import("../../types/CSSUnit").CSSUnit | `calc(${string})`) | undefined;
+    open: boolean;
+    setOpen: (newOpen: boolean) => void;
+};
+export { useTooltip };

package/dist/Tooltip/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Tooltip";
+export * from "./TooltipTrigger";
+export * from "./TooltipContent";
+export * from "./TooltipContext";

package/dist/index.d.ts

@@ -16,4 +16,6 @@ export * from "./Tabs";
 export * from "./Text";
 export * from "./Textarea";
 export * from "./ThemesProvider";
+export * from "./Tooltip";
+export * from "./ModalsManager";
 export * from "./utils";