@bolio-ui/core 3.0.5 → 3.1.0

package/esm/use-file-dialog/index.d.ts

@@ -0,0 +1,3 @@
+import useFileDialog from './use-file-dialog';
+export type { UseFileDialogOptions, UseFileDialogResult } from './use-file-dialog';
+export default useFileDialog;

package/esm/use-file-dialog/index.js

@@ -0,0 +1,8 @@
+'use client';
+import {
+  use_file_dialog_default
+} from "../chunk-BI3KST5Z.js";
+import "../chunk-ZRORQ2WH.js";
+export {
+  use_file_dialog_default as default
+};

package/esm/use-file-dialog/use-file-dialog.d.ts

@@ -0,0 +1,13 @@
+export type UseFileDialogOptions = {
+    multiple?: boolean;
+    accept?: string;
+    capture?: string;
+    onChange?: (files: FileList | null) => void;
+};
+export type UseFileDialogResult = {
+    files: FileList | null;
+    open: () => void;
+    reset: () => void;
+};
+declare const useFileDialog: (options?: UseFileDialogOptions) => UseFileDialogResult;
+export default useFileDialog;

package/esm/use-floating-window/index.d.ts

@@ -0,0 +1,3 @@
+import useFloatingWindow from './use-floating-window';
+export type { UseFloatingWindowOptions, UseFloatingWindowResult } from './use-floating-window';
+export default useFloatingWindow;

package/esm/use-floating-window/index.js

@@ -0,0 +1,7 @@
+'use client';
+import {
+  use_floating_window_default
+} from "../chunk-3LVOPXHK.js";
+export {
+  use_floating_window_default as default
+};

package/esm/use-floating-window/use-floating-window.d.ts

@@ -0,0 +1,15 @@
+import type { RefObject } from 'react';
+export type UseFloatingWindowOptions = {
+    initialPosition?: {
+        x: number;
+        y: number;
+    };
+};
+export type UseFloatingWindowResult<T extends HTMLElement, H extends HTMLElement> = {
+    ref: RefObject<T | null>;
+    handleRef: RefObject<H | null>;
+    style: React.CSSProperties;
+    dragging: boolean;
+};
+declare const useFloatingWindow: <T extends HTMLElement = HTMLElement, H extends HTMLElement = HTMLElement>({ initialPosition }?: UseFloatingWindowOptions) => UseFloatingWindowResult<T, H>;
+export default useFloatingWindow;

package/esm/use-focus-return/index.d.ts

@@ -0,0 +1,3 @@
+import useFocusReturn from './use-focus-return';
+export type { UseFocusReturnOptions } from './use-focus-return';
+export default useFocusReturn;

package/esm/use-focus-return/index.js

@@ -0,0 +1,7 @@
+'use client';
+import {
+  use_focus_return_default
+} from "../chunk-MVCROFQ6.js";
+export {
+  use_focus_return_default as default
+};

package/esm/use-focus-return/use-focus-return.d.ts

@@ -0,0 +1,6 @@
+export type UseFocusReturnOptions = {
+    opened: boolean;
+    shouldReturnFocus?: boolean;
+};
+declare const useFocusReturn: ({ opened, shouldReturnFocus }: UseFocusReturnOptions) => () => void;
+export default useFocusReturn;

package/esm/use-focus-trap/index.d.ts

@@ -0,0 +1,2 @@
+import useFocusTrap from './use-focus-trap';
+export default useFocusTrap;

package/esm/use-focus-trap/index.js

@@ -0,0 +1,7 @@
+'use client';
+import {
+  use_focus_trap_default
+} from "../chunk-J3VM74M7.js";
+export {
+  use_focus_trap_default as default
+};

package/esm/use-focus-trap/use-focus-trap.d.ts

@@ -0,0 +1,3 @@
+import type { RefObject } from 'react';
+declare const useFocusTrap: <T extends HTMLElement = HTMLElement>(active?: boolean) => RefObject<T | null>;
+export default useFocusTrap;

package/esm/use-focus-within/index.d.ts

@@ -0,0 +1,3 @@
+import useFocusWithin from './use-focus-within';
+export type { UseFocusWithinOptions, UseFocusWithinResult } from './use-focus-within';
+export default useFocusWithin;

package/esm/use-focus-within/index.js

@@ -0,0 +1,8 @@
+'use client';
+import {
+  use_focus_within_default
+} from "../chunk-LWP3PTKW.js";
+import "../chunk-ZRORQ2WH.js";
+export {
+  use_focus_within_default as default
+};

package/esm/use-focus-within/use-focus-within.d.ts

@@ -0,0 +1,11 @@
+import type { RefObject } from 'react';
+export type UseFocusWithinOptions = {
+    onFocus?: (event: FocusEvent) => void;
+    onBlur?: (event: FocusEvent) => void;
+};
+export type UseFocusWithinResult<T extends HTMLElement> = {
+    ref: RefObject<T | null>;
+    focused: boolean;
+};
+declare const useFocusWithin: <T extends HTMLElement = HTMLElement>(options?: UseFocusWithinOptions) => UseFocusWithinResult<T>;
+export default useFocusWithin;

package/esm/use-force-update/index.d.ts

@@ -0,0 +1,2 @@
+import useForceUpdate from './use-force-update';
+export default useForceUpdate;

package/esm/use-force-update/index.js

@@ -0,0 +1,7 @@
+'use client';
+import {
+  use_force_update_default
+} from "../chunk-FZEN4BUH.js";
+export {
+  use_force_update_default as default
+};

package/esm/use-force-update/use-force-update.d.ts

@@ -0,0 +1,2 @@
+declare const useForceUpdate: () => import("react").ActionDispatch<[]>;
+export default useForceUpdate;

package/esm/use-form/form-context.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { UseFormReturn } from './use-form';
+export declare const FormProvider: <Values extends Record<string, unknown>, Transformed = Values>({ form, children }: {
+    form: UseFormReturn<Values, Transformed>;
+    children?: React.ReactNode;
+}) => React.JSX.Element;
+export declare const useFormContext: <Values extends Record<string, unknown> = Record<string, unknown>, Transformed = Values>() => UseFormReturn<Values, Transformed>;

package/esm/use-form/index.d.ts

@@ -0,0 +1,6 @@
+import useForm from './use-form';
+export { FormProvider, useFormContext } from './form-context';
+export type { CheckboxFieldProps, FormErrors, FormRules, GetInputPropsOptions, UseFormOptions, UseFormReturn, ValueFieldProps } from './use-form';
+export type { FormRule } from './validators';
+export { hasLength, isEmail, isInRange, isNotEmpty, matches, matchesField } from './validators';
+export default useForm;

package/esm/use-form/index.js

@@ -0,0 +1,23 @@
+'use client';
+import {
+  FormProvider,
+  hasLength,
+  isEmail,
+  isInRange,
+  isNotEmpty,
+  matches,
+  matchesField,
+  useFormContext,
+  use_form_default
+} from "../chunk-EZL2HZZS.js";
+export {
+  FormProvider,
+  use_form_default as default,
+  hasLength,
+  isEmail,
+  isInRange,
+  isNotEmpty,
+  matches,
+  matchesField,
+  useFormContext
+};

package/esm/use-form/use-form.d.ts

@@ -0,0 +1,84 @@
+export type FormErrors = Record<string, string>;
+export type FormRules<Values> = Record<string, unknown> | ((values: Values) => FormErrors);
+export type UseFormOptions<Values, Transformed = Values> = {
+    initialValues: Values;
+    /** Shapes the values `onSubmit` hands to its handler. */
+    transformValues?: (values: Values) => Transformed;
+    validate?: FormRules<Values>;
+    /** `true` validates every field on change, an array only the listed paths. */
+    validateInputOnChange?: boolean | string[];
+    /** `true` validates every field on blur, an array only the listed paths. */
+    validateInputOnBlur?: boolean | string[];
+    /** `false` keeps a field error while the field changes. */
+    clearInputErrorOnChange?: boolean;
+    /** Runs after the values change, but not after `initialize`. */
+    onValuesChange?: (values: Values) => void;
+};
+export type GetInputPropsOptions = {
+    type?: 'input' | 'checkbox';
+};
+type FieldError = {
+    error?: boolean;
+    errorMessage?: string;
+};
+export type ValueFieldProps = FieldError & {
+    value: any;
+    onChange: (arg: any) => void;
+    onBlur: () => void;
+};
+export type CheckboxFieldProps = FieldError & {
+    checked: boolean;
+    onChange: (event: {
+        target: {
+            checked: boolean;
+        };
+    }) => void;
+    onBlur: () => void;
+};
+declare const useForm: <Values extends Record<string, unknown>, Transformed = Values>({ initialValues, transformValues, validate: rules, validateInputOnChange, validateInputOnBlur, clearInputErrorOnChange, onValuesChange }: UseFormOptions<Values, Transformed>) => {
+    values: Values;
+    errors: FormErrors;
+    submitting: boolean;
+    getInputProps: {
+        (path: string, options: {
+            type: "checkbox";
+        }): CheckboxFieldProps;
+        (path: string, options?: {
+            type?: "input";
+        }): ValueFieldProps;
+    };
+    onSubmit: (handleValues: (values: Transformed, event?: React.FormEvent) => unknown, handleErrors?: (errors: FormErrors, values: Values) => void) => (event?: React.FormEvent) => Promise<void>;
+    onReset: (event?: React.FormEvent) => void;
+    reset: () => void;
+    initialize: (next: Values) => void;
+    getValues: () => Values;
+    getTransformedValues: (current?: Values) => Transformed;
+    setInitialValues: import("react").Dispatch<import("react").SetStateAction<Values>>;
+    resetDirty: (next?: Values) => void;
+    resetTouched: () => void;
+    validate: () => {
+        hasErrors: boolean;
+        errors: FormErrors;
+    };
+    validateField: (path: string, current?: Values) => boolean;
+    setFieldValue: (path: string, value: unknown) => void;
+    setValues: (next: Partial<Values>) => void;
+    setErrors: import("react").Dispatch<import("react").SetStateAction<FormErrors>>;
+    setFieldError: (path: string, message: string) => void;
+    clearErrors: () => void;
+    clearFieldError: (path: string) => void;
+    insertListItem: (path: string, item: unknown, index?: number) => void;
+    removeListItem: (path: string, index: number) => void;
+    reorderListItem: (path: string, { from, to }: {
+        from: number;
+        to: number;
+    }) => void;
+    isDirty: (path?: string) => boolean;
+    isValid: (path?: string) => boolean;
+    isTouched: (path?: string) => boolean;
+    getTouched: () => Record<string, boolean>;
+    setFieldTouched: (path: string, value?: boolean) => void;
+    replaceListItem: (path: string, index: number, item: unknown) => void;
+};
+export type UseFormReturn<Values extends Record<string, unknown>, Transformed = Values> = ReturnType<typeof useForm<Values, Transformed>>;
+export default useForm;

package/esm/use-form/validators.d.ts

@@ -0,0 +1,14 @@
+export type FormRule<Value = unknown, Values = unknown> = (value: Value, values: Values, path: string) => string | null | undefined;
+export declare const isNotEmpty: (message: string) => FormRule;
+export declare const isEmail: (message: string) => FormRule;
+export declare const matches: (pattern: RegExp, message: string) => FormRule;
+export declare const hasLength: (length: number | {
+    min?: number;
+    max?: number;
+}, message: string) => FormRule;
+export declare const isInRange: ({ min, max }: {
+    min?: number;
+    max?: number;
+}, message: string) => FormRule;
+export declare const matchesField: (path: string, message: string) => FormRule;
+export declare const getPath: (source: unknown, path: string) => unknown;

package/esm/use-fullscreen/index.d.ts

@@ -0,0 +1,3 @@
+import useFullscreen from './use-fullscreen';
+export type { UseFullscreenResult } from './use-fullscreen';
+export default useFullscreen;

package/esm/use-fullscreen/index.js

@@ -0,0 +1,7 @@
+'use client';
+import {
+  use_fullscreen_default
+} from "../chunk-VSSO6Y76.js";
+export {
+  use_fullscreen_default as default
+};

package/esm/use-fullscreen/use-fullscreen.d.ts

@@ -0,0 +1,10 @@
+import type { RefObject } from 'react';
+export type UseFullscreenResult<T extends HTMLElement> = {
+    ref: RefObject<T | null>;
+    fullscreen: boolean;
+    enter: () => Promise<void>;
+    exit: () => Promise<void>;
+    toggle: () => Promise<void>;
+};
+declare const useFullscreen: <T extends HTMLElement = HTMLElement>() => UseFullscreenResult<T>;
+export default useFullscreen;

package/esm/use-hash/index.d.ts

@@ -0,0 +1,2 @@
+import useHash from './use-hash';
+export default useHash;

package/esm/use-hash/index.js

@@ -0,0 +1,7 @@
+'use client';
+import {
+  use_hash_default
+} from "../chunk-JIN7XD6G.js";
+export {
+  use_hash_default as default
+};

package/esm/use-hash/use-hash.d.ts

@@ -0,0 +1,2 @@
+declare const useHash: () => [string, (value: string) => void];
+export default useHash;

package/esm/use-headroom/index.d.ts

@@ -0,0 +1,3 @@
+import useHeadroom from './use-headroom';
+export type { UseHeadroomOptions } from './use-headroom';
+export default useHeadroom;

package/esm/use-headroom/index.js

@@ -0,0 +1,8 @@
+'use client';
+import {
+  use_headroom_default
+} from "../chunk-HUK4C3ZR.js";
+import "../chunk-ZRORQ2WH.js";
+export {
+  use_headroom_default as default
+};

package/esm/use-headroom/use-headroom.d.ts

@@ -0,0 +1,8 @@
+export type UseHeadroomOptions = {
+    fixedAt?: number;
+    onPin?: () => void;
+    onFix?: () => void;
+    onRelease?: () => void;
+};
+declare const useHeadroom: ({ fixedAt, onPin, onFix, onRelease }?: UseHeadroomOptions) => boolean;
+export default useHeadroom;

package/esm/use-hover/index.d.ts

@@ -0,0 +1,3 @@
+import useHover from './use-hover';
+export type { UseHoverResult } from './use-hover';
+export default useHover;

package/esm/use-hover/index.js

@@ -0,0 +1,7 @@
+'use client';
+import {
+  use_hover_default
+} from "../chunk-DBXNG475.js";
+export {
+  use_hover_default as default
+};

package/esm/use-hover/use-hover.d.ts

@@ -0,0 +1,7 @@
+import type { RefObject } from 'react';
+export type UseHoverResult<T extends HTMLElement> = {
+    hovered: boolean;
+    ref: RefObject<T | null>;
+};
+declare const useHover: <T extends HTMLElement = HTMLElement>() => UseHoverResult<T>;
+export default useHover;

package/esm/use-idle/index.d.ts

@@ -0,0 +1,3 @@
+import useIdle from './use-idle';
+export type { UseIdleOptions } from './use-idle';
+export default useIdle;

package/esm/use-idle/index.js

@@ -0,0 +1,7 @@
+'use client';
+import {
+  use_idle_default
+} from "../chunk-OLNIDUBW.js";
+export {
+  use_idle_default as default
+};

package/esm/use-idle/use-idle.d.ts

@@ -0,0 +1,6 @@
+export type UseIdleOptions = {
+    events?: string[];
+    initialState?: boolean;
+};
+declare const useIdle: (timeout: number, { events, initialState }?: UseIdleOptions) => boolean;
+export default useIdle;

package/esm/use-in-viewport/index.d.ts

@@ -0,0 +1,3 @@
+import useInViewport from './use-in-viewport';
+export type { UseInViewportResult } from './use-in-viewport';
+export default useInViewport;

package/esm/use-in-viewport/index.js

@@ -0,0 +1,8 @@
+'use client';
+import {
+  use_in_viewport_default
+} from "../chunk-IP4EY3F3.js";
+import "../chunk-5F7SJI6T.js";
+export {
+  use_in_viewport_default as default
+};

package/esm/use-in-viewport/use-in-viewport.d.ts

@@ -0,0 +1,6 @@
+export type UseInViewportResult<T extends HTMLElement> = {
+    ref: (element: T | null) => void;
+    inViewport: boolean;
+};
+declare const useInViewport: <T extends HTMLElement = HTMLElement>() => UseInViewportResult<T>;
+export default useInViewport;

package/esm/use-input/index.js

@@ -1,9 +1,9 @@
 'use client';
 import {
   use_input_default
-} from "../chunk-J4K4LRBI.js";
-import "../chunk-33BUV2RX.js";
-import "../chunk-GGD4BGH2.js";
+} from "../chunk-QCLQ5AJX.js";
+import "../chunk-E4LPRAZ6.js";
+import "../chunk-OOU3TSOA.js";
 export {
   use_input_default as default
 };

package/esm/use-input/use-input.d.ts

@@ -1,4 +1,5 @@
-import React, { Dispatch, MutableRefObject, SetStateAction } from 'react';
+import type { Dispatch, MutableRefObject, SetStateAction } from 'react';
+import type React from 'react';
 export type BindingsChangeTarget = React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement> | string;
 declare const useInput: (initialValue: string) => {
     state: string;

package/esm/use-input-state/index.d.ts

@@ -0,0 +1,2 @@
+import useInputState from './use-input-state';
+export default useInputState;

package/esm/use-input-state/index.js

@@ -0,0 +1,7 @@
+'use client';
+import {
+  use_input_state_default
+} from "../chunk-EKASDDSU.js";
+export {
+  use_input_state_default as default
+};

package/esm/use-input-state/use-input-state.d.ts

@@ -0,0 +1,4 @@
+import type { ChangeEvent } from 'react';
+type InputChange<T> = T | ChangeEvent<HTMLInputElement | HTMLTextAreaElement>;
+declare const useInputState: <T>(initialValue: T) => [T, (value: InputChange<T>) => void];
+export default useInputState;

package/esm/use-intersection/index.d.ts

@@ -0,0 +1,3 @@
+import useIntersection from './use-intersection';
+export type { UseIntersectionResult } from './use-intersection';
+export default useIntersection;

package/esm/use-intersection/index.js

@@ -0,0 +1,7 @@
+'use client';
+import {
+  use_intersection_default
+} from "../chunk-5F7SJI6T.js";
+export {
+  use_intersection_default as default
+};

package/esm/use-intersection/use-intersection.d.ts

@@ -0,0 +1,6 @@
+export type UseIntersectionResult<T extends HTMLElement> = {
+    ref: (element: T | null) => void;
+    entry: IntersectionObserverEntry | null;
+};
+declare const useIntersection: <T extends HTMLElement = HTMLElement>(options?: IntersectionObserverInit) => UseIntersectionResult<T>;
+export default useIntersection;

package/esm/use-interval/index.d.ts

@@ -0,0 +1,3 @@
+import useInterval from './use-interval';
+export type { UseIntervalOptions, UseIntervalResult } from './use-interval';
+export default useInterval;

package/esm/use-interval/index.js

@@ -0,0 +1,8 @@
+'use client';
+import {
+  use_interval_default
+} from "../chunk-MFC6RKLT.js";
+import "../chunk-ZRORQ2WH.js";
+export {
+  use_interval_default as default
+};

package/esm/use-interval/use-interval.d.ts

@@ -0,0 +1,11 @@
+export type UseIntervalOptions = {
+    autoInvoke?: boolean;
+};
+export type UseIntervalResult = {
+    start: () => void;
+    stop: () => void;
+    toggle: () => void;
+    active: boolean;
+};
+declare const useInterval: (fn: () => void, interval: number, { autoInvoke }?: UseIntervalOptions) => UseIntervalResult;
+export default useInterval;

package/esm/use-is-first-render/index.d.ts

@@ -0,0 +1,2 @@
+import useIsFirstRender from './use-is-first-render';
+export default useIsFirstRender;

package/esm/use-is-first-render/index.js

@@ -0,0 +1,7 @@
+'use client';
+import {
+  use_is_first_render_default
+} from "../chunk-MPQMRC77.js";
+export {
+  use_is_first_render_default as default
+};

package/esm/use-is-first-render/use-is-first-render.d.ts

@@ -0,0 +1,2 @@
+declare const useIsFirstRender: () => boolean;
+export default useIsFirstRender;

package/esm/use-isomorphic-effect/index.d.ts

@@ -0,0 +1,2 @@
+import useIsomorphicEffect from './use-isomorphic-effect';
+export default useIsomorphicEffect;

package/esm/use-isomorphic-effect/index.js

@@ -0,0 +1,7 @@
+'use client';
+import {
+  use_isomorphic_effect_default
+} from "../chunk-XTRGAC3F.js";
+export {
+  use_isomorphic_effect_default as default
+};

package/esm/use-isomorphic-effect/use-isomorphic-effect.d.ts

@@ -0,0 +1,3 @@
+import { useEffect } from 'react';
+declare const useIsomorphicEffect: typeof useEffect;
+export default useIsomorphicEffect;