@apple-pie/slice 0.1.9 → 0.1.10

package/dist/types/components/Slider/index.d.ts

@@ -0,0 +1,2 @@
+export { Slider } from './Slider';
+export type { SliderProps } from './_types';

package/dist/types/components/Spacer/Spacer.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { SpacerProps } from './_types';
+export declare const Spacer: React.MemoExoticComponent<(props: SpacerProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/types/components/Spacer/_types.d.ts

@@ -0,0 +1,6 @@
+import type React from 'react';
+type SpacerBaseProps = {
+    size?: number;
+};
+export type SpacerProps = Omit<React.HTMLAttributes<HTMLDivElement>, keyof SpacerBaseProps> & SpacerBaseProps;
+export {};

package/dist/types/components/Spacer/index.d.ts

@@ -0,0 +1,2 @@
+export { Spacer } from '../Spacer/Spacer';
+export type { SpacerProps } from './_types';

package/dist/types/components/Switch/Switch.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { SwitchProps } from './_types';
+export declare const Switch: React.MemoExoticComponent<(props: SwitchProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/types/components/Switch/Switch.stories.d.ts

@@ -0,0 +1,5 @@
+import type { Meta, StoryObj } from '@storybook/react-vite';
+import { Switch } from 'src/components/Switch';
+declare const meta: Meta<typeof Switch>;
+export default meta;
+export declare const Default: StoryObj<typeof Switch>;

package/dist/types/components/Switch/_types.d.ts

@@ -0,0 +1,13 @@
+import type React from 'react';
+type SwitchBaseProps = {
+    state?: boolean;
+    height?: number;
+    width?: number;
+    bgColorOff?: string;
+    bgColorOn?: string;
+    knobColor?: string;
+    padding?: number;
+    onChange?: (state: boolean) => void;
+};
+export type SwitchProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, keyof SwitchBaseProps> & SwitchBaseProps;
+export {};

package/dist/types/components/Switch/index.d.ts

@@ -0,0 +1,2 @@
+export { Switch } from './Switch';
+export type { SwitchProps } from './_types';

package/dist/types/components/TabBar/TabBar.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { TabBarProps } from './_types';
+export declare const TabBar: React.MemoExoticComponent<(props: TabBarProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/types/components/TabBar/_types.d.ts

@@ -0,0 +1,52 @@
+import type React from 'react';
+import type { ToolTip } from '../sharedTypes';
+export type TabOption = {
+    name?: string;
+    value?: any;
+    icon?: string | null;
+    toolTip?: string;
+    count?: number;
+    component?: any;
+};
+export declare const placeholderOptions: TabOption[];
+type TabBarBaseProps = {
+    options?: TabOption[];
+    selected?: number;
+    underline?: boolean;
+    border?: boolean;
+    selectedValue?: string;
+    height?: number | string;
+    width?: number | string;
+    tabWidth?: 'min-content' | 'distribute' | number;
+    closeWidth?: number | string;
+    padding?: number | string;
+    iconSize?: number;
+    iconGap?: number;
+    tabGap?: number;
+    disabled?: boolean;
+    hasClose?: boolean;
+    onToolTip?: (tip: ToolTip | null) => void;
+    onChange?: (index: number) => void;
+    onTabChange?: (option: TabOption) => void;
+    onClose?: () => void;
+};
+export type TabBarProps = Omit<React.HTMLAttributes<HTMLDivElement>, keyof TabBarBaseProps> & TabBarBaseProps;
+export interface TabOptionProps {
+    label?: string;
+    value?: number;
+    icon?: string | null;
+    showToolTip?: string | null;
+    selected?: boolean;
+    padding?: number | string;
+    iconSize?: number;
+    iconGap?: number;
+    disabled?: boolean;
+    count?: number;
+    tabWidth?: 'min-content' | 'distribute' | number;
+    underline?: boolean;
+    onClick?: (value: number) => void;
+    onKeyDown?: (event: React.KeyboardEvent<HTMLButtonElement>, value: number) => void;
+    onToolTip?: (tip: ToolTip | null) => void;
+    buttonRef?: (element: HTMLButtonElement | null) => void;
+}
+export {};

package/dist/types/components/TabBar/index.d.ts

@@ -0,0 +1,2 @@
+export { TabBar } from './TabBar';
+export type { TabBarProps, TabOption } from './_types';

package/dist/types/components/TextArea/TextArea.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { TextAreaProps } from './_types';
+export declare const TextArea: React.MemoExoticComponent<(props: TextAreaProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/types/components/TextArea/_types.d.ts

@@ -0,0 +1,41 @@
+import type React from 'react';
+type TextAreaBaseProps = {
+    value?: string;
+    name?: string;
+    width?: number | string;
+    height?: number | string;
+    minWidth?: number | string;
+    rows?: number;
+    focused?: boolean;
+    placeholder?: string;
+    padding?: number | string;
+    validate?: boolean;
+    border?: boolean;
+    resizable?: boolean;
+    hasSend?: boolean;
+    sendOffset?: {
+        bottom: number;
+        right: number;
+    };
+    sendSize?: number;
+    bgColor?: string;
+    borderRadius?: number;
+    returnSubmits?: boolean;
+    textSize?: 's' | 'm' | 'l';
+    disabled?: boolean;
+    submitClears?: boolean;
+    onChange?: (value: string) => void;
+    onSubmit?: (value: string) => void;
+    onFocus?: () => void;
+    onBlur?: () => void;
+    onValidate?: (state: boolean) => void;
+    onKeyDown?: (e: React.KeyboardEvent<HTMLTextAreaElement>) => void;
+};
+export type TextAreaProps = Omit<React.HTMLAttributes<HTMLDivElement>, keyof TextAreaBaseProps> & TextAreaBaseProps;
+export type Tip = {
+    icon?: string;
+    iconRight?: boolean;
+    key: string;
+    label?: string;
+};
+export {};

package/dist/types/components/TextArea/index.d.ts

@@ -0,0 +1,2 @@
+export { TextArea } from './TextArea';
+export type { TextAreaProps, Tip } from './_types';

package/dist/types/components/Textfield/TextField.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { type TextFieldProps } from './_types';
+export declare const TextField: React.MemoExoticComponent<(props: TextFieldProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/types/components/Textfield/_types.d.ts

@@ -0,0 +1,79 @@
+import type { Transition } from 'motion/react';
+import type React from 'react';
+type TextFieldBaseProps = {
+    value?: string;
+    name?: string;
+    label?: string;
+    labelSize?: 's' | 'm' | 'l';
+    textSize?: 's' | 'm' | 'l';
+    placeholder?: string;
+    focused?: boolean;
+    editable?: boolean;
+    onChange?: (value: string) => void;
+    onBlur?: (value: string) => void;
+    onFocus?: (value: string) => void;
+    onKeydown?: (key: string, event: React.KeyboardEvent) => void;
+    onSubmit?: (value: string) => void;
+    onPaste?: (value: React.ClipboardEvent<HTMLInputElement>) => void;
+    onClear?: () => void;
+    onAction?: () => void;
+    onValidate?: (state: boolean) => void;
+    isValid?: boolean;
+    inline?: boolean;
+    maxLength?: number;
+    size?: {
+        width?: number | string;
+        height?: number | string;
+    };
+    padding?: string;
+    borderRadius?: number | string;
+    textAlign?: 'left' | 'center';
+    borderColor?: {
+        focused: string;
+        blurred: string;
+        error: string;
+    };
+    backgroundColor?: {
+        focused: string;
+        blurred: string;
+    };
+    color?: {
+        focused: string;
+        blurred: string;
+        error: string;
+        placeholder: string;
+        disabled: string;
+        label: string;
+    };
+    validate?: boolean;
+    iconLeft?: {
+        name?: string;
+        size?: number;
+        color?: string;
+    };
+    clearButton?: {
+        size?: number;
+    } | null;
+    clearBlurs?: boolean;
+    disabled?: boolean;
+    actionButton?: boolean;
+    borderType?: 'box' | 'underline' | 'none';
+    inputType?: 'text' | 'password';
+    noShow?: boolean;
+};
+export type TextFieldProps = Omit<React.HTMLAttributes<HTMLDivElement>, keyof TextFieldBaseProps> & TextFieldBaseProps;
+export declare const MOTION_CONFIG: {
+    variants: {
+        initial: {
+            opacity: number;
+        };
+        animate: {
+            opacity: number;
+        };
+        exit: {
+            opacity: number;
+        };
+    };
+    transition: Transition;
+};
+export {};

package/dist/types/components/Textfield/index.d.ts

@@ -0,0 +1,2 @@
+export { TextField } from './TextField';
+export type { TextFieldProps } from './_types';

package/dist/types/components/Tip/Tip.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { type ToolTipProps } from './_types';
+export declare const Tip: React.NamedExoticComponent<Omit<ToolTipProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/types/components/Tip/_types.d.ts

@@ -0,0 +1,28 @@
+import type { HTMLMotionProps } from 'motion/react';
+import type { ToolTip } from '../sharedTypes';
+export declare const tipBasePos: {
+    left: number;
+    top: number;
+};
+export type PosCoords = {
+    left: number;
+    top: number;
+};
+type ToolTipBaseProps = {
+    tip?: ToolTip | null;
+    size?: 's' | 'm' | 'l';
+    bgColor?: string;
+    color?: string;
+    border?: boolean;
+    borderColor?: string;
+    padding?: number | string;
+    radius?: number;
+    coords?: {
+        x: number;
+        y: number;
+    };
+    showDelay?: number;
+    hideDelay?: number;
+};
+export type ToolTipProps = Omit<HTMLMotionProps<'div'>, keyof ToolTipBaseProps> & ToolTipBaseProps;
+export {};

package/dist/types/components/Tip/index.d.ts

@@ -0,0 +1,2 @@
+export { Tip } from './Tip';
+export type { ToolTipProps } from './_types';

package/dist/types/components/Toast/Toast.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { type ToastProps } from './_types';
+export declare const Toast: React.NamedExoticComponent<Omit<ToastProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/types/components/Toast/_types.d.ts

@@ -0,0 +1,24 @@
+import type { HTMLMotionProps } from 'motion/react';
+export declare enum ToastType {
+    Success = "success",
+    Error = "error",
+    Warning = "warning",
+    Info = "info"
+}
+type ToastBaseProps = {
+    message?: string | null;
+    size?: 's' | 'm' | 'l';
+    border?: boolean;
+    padding?: number | string;
+    radius?: number | string;
+    position?: 'top' | 'bottom';
+    offset?: number;
+    showDelay?: number;
+    duration?: number | 'Infinite';
+    close?: boolean;
+    type?: ToastType;
+    didHide?: () => void;
+};
+type ReservedToastEvents = 'onMouseEnter' | 'onMouseLeave' | 'onFocus' | 'onBlur';
+export type ToastProps = Omit<HTMLMotionProps<'div'>, keyof ToastBaseProps | ReservedToastEvents> & ToastBaseProps;
+export {};

package/dist/types/components/Toast/index.d.ts

@@ -0,0 +1,2 @@
+export { Toast } from './Toast';
+export { type ToastProps, ToastType } from './_types';

package/dist/types/components/UploadArea/UploadArea.d.ts

@@ -0,0 +1,54 @@
+import React from 'react';
+export declare const UploadArea: React.NamedExoticComponent<Omit<React.HTMLAttributes<HTMLDivElement>, keyof {
+    icon?: string;
+    iconSize?: number;
+    iconColor?: string;
+    iconColorHover?: string;
+    width?: number | string;
+    height?: number | string;
+    title?: string;
+    message?: string;
+    busyMessage?: string;
+    bgColor?: string;
+    bgColorHover?: string;
+    border?: number;
+    borderColor?: string | null;
+    borderColorHover?: string | null;
+    borderStyle?: string;
+    textSize?: "s" | "m" | "l";
+    padding?: number | string;
+    radius?: number | string;
+    acceptedTypes?: string[];
+    multiple?: boolean;
+    busy?: boolean;
+    showProgress?: boolean;
+    files?: import("../FileList").FileItem[];
+    canRemove?: boolean;
+    onUpload?: (files: File[]) => void;
+}> & {
+    icon?: string;
+    iconSize?: number;
+    iconColor?: string;
+    iconColorHover?: string;
+    width?: number | string;
+    height?: number | string;
+    title?: string;
+    message?: string;
+    busyMessage?: string;
+    bgColor?: string;
+    bgColorHover?: string;
+    border?: number;
+    borderColor?: string | null;
+    borderColorHover?: string | null;
+    borderStyle?: string;
+    textSize?: "s" | "m" | "l";
+    padding?: number | string;
+    radius?: number | string;
+    acceptedTypes?: string[];
+    multiple?: boolean;
+    busy?: boolean;
+    showProgress?: boolean;
+    files?: import("../FileList").FileItem[];
+    canRemove?: boolean;
+    onUpload?: (files: File[]) => void;
+} & React.RefAttributes<HTMLDivElement>>;

package/dist/types/components/UploadArea/_types.d.ts

@@ -0,0 +1,46 @@
+import type React from 'react';
+import type { FileItem } from '../FileList';
+export declare const imageTypes: string[];
+export declare const videoTypes: string[];
+export declare const documentTypes: string[];
+export declare const audioTypes: string[];
+export declare const textTypes: string[];
+export declare const allTypes: string[];
+export declare enum FileTypes {
+    images = "images",
+    videos = "videos",
+    documents = "documents",
+    audio = "audio",
+    text = "text",
+    all = "all",
+    custom = "custom"
+}
+type UploadAreaBaseProps = {
+    icon?: string;
+    iconSize?: number;
+    iconColor?: string;
+    iconColorHover?: string;
+    width?: number | string;
+    height?: number | string;
+    title?: string;
+    message?: string;
+    busyMessage?: string;
+    bgColor?: string;
+    bgColorHover?: string;
+    border?: number;
+    borderColor?: string | null;
+    borderColorHover?: string | null;
+    borderStyle?: string;
+    textSize?: 's' | 'm' | 'l';
+    padding?: number | string;
+    radius?: number | string;
+    acceptedTypes?: string[];
+    multiple?: boolean;
+    busy?: boolean;
+    showProgress?: boolean;
+    files?: FileItem[];
+    canRemove?: boolean;
+    onUpload?: (files: File[]) => void;
+};
+export type UploadAreaProps = Omit<React.HTMLAttributes<HTMLDivElement>, keyof UploadAreaBaseProps> & UploadAreaBaseProps;
+export {};

package/dist/types/components/UploadArea/index.d.ts

@@ -0,0 +1,3 @@
+export { UploadArea } from './UploadArea';
+export type { UploadAreaProps } from './_types';
+export { imageTypes, videoTypes, documentTypes, audioTypes, textTypes, allTypes, } from './_types';

package/dist/types/components/playHelpers.d.ts

@@ -0,0 +1,35 @@
+type PlayContext<TArgs = unknown> = {
+    args: TArgs;
+    canvasElement: HTMLElement;
+};
+export declare function runAvatarGroupPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runBadgePlay<TArgs>({ canvasElement, args, }: PlayContext<TArgs>): Promise<void>;
+export declare function runCheckBoxPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runDivInputPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runDotPlay<TArgs>({ canvasElement }: PlayContext<TArgs>): Promise<void>;
+export declare function runDraggablePanelPlay<TArgs>({ canvasElement, args, }: PlayContext<TArgs>): Promise<void>;
+export declare function runDropDownPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runErrorSummaryPlay<TArgs>({ canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runFlexDivPlay<TArgs>({ canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runGrouperPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runIconPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runIconButtonPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runLogosPlay<TArgs>({ canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runOverlayPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runPagerPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runProgressIndicatorPlay<TArgs>({ canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runRadioButtonPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runRadioButtonListPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runSliderPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runSpacerPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runSwitchPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runTabBarPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runTextAreaPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runTextFieldPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runButtonPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runButtonBarPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runCardPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runChipPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runUIFileIconPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export declare function runLabelPlay<TArgs>({ args, canvasElement, }: PlayContext<TArgs>): Promise<void>;
+export {};

package/dist/types/components/sharedTypes.d.ts

@@ -0,0 +1,21 @@
+import type React from 'react';
+export type ToolTip = {
+    type?: ToolTipType;
+    payload?: {
+        label: string;
+        duration?: number;
+    };
+    ref?: React.RefObject<any> | null;
+    event?: MouseEvent | React.MouseEvent<any>;
+};
+export declare enum ToolTipType {
+    menu = "menu",
+    button = "button",
+    general = "general",
+    other = "other"
+}
+export type ToolTipInfo = {
+    title?: string | null;
+    description?: string | null;
+    image?: string | null;
+};

package/dist/types/hooks/index.d.ts

@@ -0,0 +1,9 @@
+export { useTheme } from './useTheme/useTheme';
+export { useObserveTheme } from './useObserveTheme/useObserveTheme';
+export { useDoubleClick } from './useDoubleClick/useDoubleClick';
+export { useToolTip } from './useToolTip/useToolTip';
+export { type KeyboardShortcut, type KeyboardShortcuts, useKeyboardShortcuts, } from './useKeyboardShortcuts/useKeyboardShortcuts';
+export { useLastUpdated } from './useLastUpdated/useLastUpdated';
+export { useLocalStore } from './useLocalStore/useLocalStore';
+export { useWindow, FormFactor, type BreakPoints, type WindowGeolocation, type WindowGeolocationError, } from './useWindow/useWindow';
+export { useObserveResize } from './useObserveResize/useObserveResize';

package/dist/types/hooks/useDoubleClick/useDoubleClick.d.ts

@@ -0,0 +1 @@
+export declare function useDoubleClick<T, Y>(onClick: (payload?: T) => void, onDblClick: (payload?: Y) => void, delay?: number): readonly [(payload: T) => () => void, (payload: Y) => void];

package/dist/types/hooks/useKeyboardShortcuts/useKeyboardShortcuts.d.ts

@@ -0,0 +1,9 @@
+export interface KeyboardShortcut {
+    key: string;
+    metaPressed?: boolean;
+    shiftPressed?: boolean;
+    altPressed?: boolean;
+    name: string;
+}
+export type KeyboardShortcuts = KeyboardShortcut[];
+export declare function useKeyboardShortcuts(shortcuts: KeyboardShortcuts, shortCutHandler: (shortcut: KeyboardShortcut) => void, isAppleDevice: boolean): void;

package/dist/types/hooks/useLastUpdated/useLastUpdated.d.ts

@@ -0,0 +1,4 @@
+export declare function useLastUpdated(timestamp: string | undefined, prefix?: string, interval?: number): {
+    lastUpdated: string;
+    timer: number;
+};

package/dist/types/hooks/useLocalStore/useLocalStore.d.ts

@@ -0,0 +1 @@
+export declare function useLocalStore<T>(key: string, value: T): readonly [T, (data: T) => void];

package/dist/types/hooks/useObserveResize/useObserveResize.d.ts

@@ -0,0 +1,9 @@
+import { type RefObject } from 'react';
+type Size = {
+    height: number;
+    width: number;
+};
+export declare function useObserveResize(element: RefObject<HTMLElement | null> | undefined, options?: {
+    ignore?: 'width' | 'height';
+}): Size;
+export {};

package/dist/types/hooks/useObserveTheme/useObserveTheme.d.ts

@@ -0,0 +1,2 @@
+import { type SliceTheme } from '../../theme';
+export declare function useObserveTheme(): SliceTheme;

package/dist/types/hooks/useTheme/useTheme.d.ts

@@ -0,0 +1,47 @@
+import type { SliceTheme } from '../../theme';
+/**
+ * Hook to manage Slice theming
+ */
+export declare function useTheme(): {
+    /**
+     * Slice's default dark theme
+     */
+    darkTheme: SliceTheme;
+    /**
+     * Slice's default light theme
+     */
+    lightTheme: SliceTheme;
+    /**
+     * The currently active SliceTheme
+     */
+    current: SliceTheme;
+    /**
+     * CSS variables for theme colors
+     */
+    colors: Record<keyof import("../..").Colors, string>;
+    /**
+     * CSS Class names for the theme colors
+     */
+    colorsClass: Record<keyof import("../..").Colors, string>;
+    /**
+     * CSS class names for theme typefaces
+     */
+    typeClass: Record<keyof import("../..").Type, string>;
+    /**
+     * CSS typeface styles as inline style properties
+     */
+    typeStyle: Record<keyof import("../..").Type, import("react").CSSProperties>;
+    /**
+     * Set a new theme by name or passing in a SliceTheme object
+     * @param newTheme
+     */
+    set: (newTheme: SliceTheme | string) => void;
+    /**
+     * Toggle between light and dark themes
+     */
+    toggle: () => void;
+    /**
+     * If the currently active theme is the Slice's default dark theme'
+     */
+    isDark: boolean;
+};

package/dist/types/hooks/useToolTip/useToolTip.d.ts

@@ -0,0 +1,6 @@
+import type React from 'react';
+import type { ToolTip } from '../../components/sharedTypes';
+export declare function useToolTip(toolTip: ToolTip | null, tipElement: React.RefObject<HTMLDivElement | null>): {
+    x: number;
+    y: number;
+} | undefined;

package/dist/types/hooks/useTrackRenders/useTrackRenders.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Hook to log component renders, mounts, and unmounts
+ * Note: wrap in comments with START.DEBUG ... {hook} ... END.DEBUG to remove from build
+ */
+export declare function useTrackRenders(props: any, componentName?: string): void;

package/dist/types/hooks/useWindow/useWindow.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Form factor names
+ */
+export declare enum FormFactor {
+    Mobile = "mobile",
+    Tablet = "tablet",
+    Desktop = "desktop",
+    DesktopL = "desktopL",
+    DesktopXL = "desktopXL"
+}
+/**
+ * Breakpoint type matching form factor to width value
+ */
+export type BreakPoints = Record<FormFactor, number>;
+export type WindowGeolocation = {
+    latitude: number;
+    longitude: number;
+    accuracy: number;
+    altitude: number | null;
+    altitudeAccuracy: number | null;
+    heading: number | null;
+    speed: number | null;
+    timestamp: number;
+};
+export type WindowGeolocationError = {
+    code: number;
+    message: string;
+};
+export declare function useWindow(breakpoints?: BreakPoints, top?: boolean): {
+    viewportWidth: number | null;
+    viewportHeight: number | null;
+    height: string;
+    isTouchDevice: boolean;
+    isElectron: boolean;
+    isAppleDevice: boolean;
+    formFactor: FormFactor;
+    dpr: 2 | 1 | 3;
+    geolocationSupported: boolean;
+    location: WindowGeolocation | null;
+    locationError: Error | null;
+    gettingLocation: boolean;
+    requestGeolocation: () => void;
+};