@react-hive/honey-layout 2.3.1 → 2.4.1

package/dist/contexts/HoneyLayoutContext.d.ts

@@ -0,0 +1,74 @@
+import { DefaultTheme, Interpolation } from 'styled-components';
+import { HoneyColorKey, HoneyCSSColor, HoneyDimensionName, HoneyFontName, HoneyOverlayConfig, HoneySpacings, Nullable, HoneyScreenState, HoneyCSSDimensionUnit, HoneyCSSDimensionValue, HoneyCSSMultiValue, HoneyOverlayId, HoneyOverlay } from '../types';
+import { ResolveSpacingResult } from '../helpers';
+/**
+ * Function to unregister a previously registered overlay.
+ */
+export type HoneyUnregisterOverlay = (targetOverlayId: HoneyOverlayId) => void;
+/**
+ * Function to register a new overlay and manage its lifecycle.
+ *
+ * @param {HoneyOverlayConfig} overlayConfig - Configuration object for the overlay.
+ */
+export type HoneyRegisterOverlay = (overlayConfig: HoneyOverlayConfig) => HoneyOverlay;
+export type HoneyLayoutContextValue = {
+    /**
+     * Represents the theme object.
+     */
+    theme: DefaultTheme;
+    /**
+     * Represents the current state of the screen.
+     */
+    screenState: HoneyScreenState;
+    /**
+     * Overlays.
+     */
+    overlays: HoneyOverlay[];
+    /**
+     * Function to register a new overlay.
+     */
+    registerOverlay: HoneyRegisterOverlay;
+    /**
+     * Function to unregister an overlay.
+     */
+    unregisterOverlay: HoneyUnregisterOverlay;
+    /**
+     * Function to resolve spacing values based on a given theme.
+     *
+     * @template MultiValue - A type representing the spacing value(s), which could be a single value or an array of values.
+     * @template Unit - The CSS unit used for the resolved spacing value, e.g., 'px', 'em'.
+     *
+     * @param {MultiValue} value - The spacing value(s) to be applied, which could be a single number or an array of numbers.
+     * @param {Unit} unit - Optional. The CSS unit to use for the calculated value. Defaults to 'px'.
+     * @param {keyof HoneySpacings} type - Optional. The type of spacing to use from the theme (e.g., 'base', 'small', 'large').
+     *
+     * @returns {ResolveSpacingResult<MultiValue, Unit>} - The resolved spacing value, formatted as a string with the appropriate unit.
+     */
+    resolveSpacing: <MultiValue extends HoneyCSSMultiValue<number>, Unit extends Nullable<HoneyCSSDimensionUnit> = 'px'>(value: MultiValue, unit?: Unit, type?: keyof HoneySpacings) => ResolveSpacingResult<MultiValue, Unit>;
+    /**
+     * Function to resolve color values based on the theme.
+     *
+     * @param {HoneyColorKey} colorKey - The key representing the color in the theme.
+     * @param {number} [alpha] - Optional alpha value to apply to the color for transparency.
+     *
+     * @returns {HoneyCSSColor} - The resolved CSS color, optionally with alpha transparency.
+     */
+    resolveColor: (colorKey: HoneyColorKey, alpha?: number) => HoneyCSSColor;
+    /**
+     * Function to resolve font styles based on the theme.
+     *
+     * @param {HoneyFontName} fontName - The name of the font to resolve from the theme.
+     *
+     * @returns {Interpolation<object>} - The CSS style rules for the specified font.
+     */
+    resolveFont: (fontName: HoneyFontName) => Interpolation<object>;
+    /**
+     * Function to resolve dimension values based on the theme.
+     *
+     * @param {HoneyDimensionName} dimensionName - The name of the dimension to resolve from the theme.
+     *
+     * @returns {HoneyCSSDimensionValue} - The resolved CSS dimension value (e.g., width, height).
+     */
+    resolveDimension: (dimensionName: HoneyDimensionName) => HoneyCSSDimensionValue;
+};
+export declare const HoneyLayoutContext: import('react').Context<HoneyLayoutContextValue | undefined>;

package/dist/contexts/index.d.ts

@@ -0,0 +1 @@
+export * from './HoneyLayoutContext';

package/dist/helpers.d.ts

@@ -1,6 +1,7 @@
 import { HTMLAttributes } from 'react';
 import { ExecutionContext, StyleFunction, css } from 'styled-components';
 import { Nullable, HoneyBreakpointName, HoneyCSSArrayValue, HoneyCSSDimensionShortHandValue, HoneyCSSDimensionUnit, HoneyCSSMultiValue, HoneyCSSMediaRule, HoneySpacings, HoneyColorKey, HoneyFontName, HoneyCSSColor, HoneyDimensionName, HoneyPrefixedCSSProperties, HoneyBreakpoints, HoneyScreenState, HoneyCSSDimensionValue } from './types';
+export declare const generateUniqueId: () => string;
 /**
  * Conditional type to determine the return type of the `resolveSpacing` function.
  *

package/dist/hooks/index.d.ts

@@ -2,3 +2,7 @@ export * from './use-honey-media-query';
 export * from './use-honey-drag';
 export * from './use-honey-infinite-scroll';
 export * from './use-honey-synthetic-scrollable-container';
+export * from './use-honey-document-key-up-handler';
+export * from './use-honey-layout';
+export * from './use-register-honey-overlay';
+export * from './use-honey-overlay';

package/dist/hooks/use-honey-document-key-up-handler.d.ts

@@ -0,0 +1,19 @@
+import { HoneyKeyboardEventCode } from '../types';
+export type HoneyDocumentKeyUpHandler = (keyCode: HoneyKeyboardEventCode, e: KeyboardEvent) => void;
+type UseHoneyDocumentKeyUpHandlerOptions = {
+    /**
+     * Determines if the event listener is active.
+     *
+     * @default true
+     */
+    isEnabled?: boolean;
+};
+/**
+ * A hook that listens for specific key up events at the document level and triggers a callback function.
+ *
+ * @param {HoneyDocumentKeyUpHandler} keyUpHandler - The callback function to be triggered when one of the specified keys is released.
+ * @param {HoneyKeyboardEventCode[]} listenKeys - An array of key codes to listen for. Only these specified keys will trigger the callback.
+ * @param {Object} options - Optional configuration.
+ */
+export declare const useHoneyDocumentKeyUpHandler: (keyUpHandler: HoneyDocumentKeyUpHandler, listenKeys: HoneyKeyboardEventCode[], { isEnabled }?: UseHoneyDocumentKeyUpHandlerOptions) => void;
+export {};

package/dist/hooks/use-honey-layout.d.ts

@@ -0,0 +1,9 @@
+import { HoneyLayoutContextValue } from '../contexts';
+/**
+ * Custom hook to access the Honey layout context.
+ *
+ * @throws Will throw an error if the hook is used outside of a `HoneyLayoutProvider` component.
+ *
+ * @returns {HoneyLayoutContextValue} - The context value providing theming utilities and screen state.
+ */
+export declare const useHoneyLayout: () => HoneyLayoutContextValue;

package/dist/hooks/use-honey-overlay.d.ts

@@ -0,0 +1,25 @@
+import { HoneyOverlayId, HoneyOverlayEventListenerHandler } from '../types';
+type UseHoneyOverlayOptions = {
+    onKeyUp?: HoneyOverlayEventListenerHandler;
+};
+/**
+ * Hook to interact with a specific overlay managed by the `HoneyLayoutProvider`.
+ *
+ * @param targetOverlayId - The unique identifier of the overlay to interact with.
+ * @param options - Configuration options for the overlay, such as keyboard event handling.
+ *
+ * @returns The overlay object associated with the provided `targetOverlayId`, or `undefined` if not found.
+ *
+ * @example
+ * ```tsx
+ * const overlay = useHoneyOverlay('my-overlay-id', {
+ *   onKeyUp: (keyCode, e) => {
+ *     if (keyCode === 'Escape') {
+ *       console.log('Escape key pressed');
+ *     }
+ *   },
+ * });
+ * ```
+ */
+export declare const useHoneyOverlay: (targetOverlayId: HoneyOverlayId, { onKeyUp }?: UseHoneyOverlayOptions) => import('../types').HoneyOverlay | undefined;
+export {};

package/dist/hooks/use-register-honey-overlay.d.ts

@@ -0,0 +1,2 @@
+import { HoneyOverlay, HoneyOverlayConfig, Nullable } from '../types';
+export declare const useRegisterHoneyOverlay: (isRegister: boolean, overlayConfig: HoneyOverlayConfig) => Nullable<HoneyOverlay>;